def foo(na, nb, fa, fb):
da = dictobject.new_dict(int32, float64)
db = dictobject.new_dict(int32, float64)
for i in range(na):
da[i] = i * fa
for i in range(nb):
db[i] = i * fb
return da == db, da != db
def foo(ak, av, bk, bv):
# The key-value types are different in the two dictionaries
da = dictobject.new_dict(int32, float64)
db = dictobject.new_dict(int64, float32)
for i in range(len(ak)):
da[ak[i]] = av[i]
for i in range(len(bk)):
db[bk[i]] = bv[i]
return da == db
def foo(keys, vals, target):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
del d[target]
return len(d), d.get(target)
def foo(keys, vals, pops):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
# popitem
return core(d, pops)
def foo(keys, vals, npop):
d = dictobject.new_dict(int32, int32)
# insertion
for k, v in zip(keys, vals):
d[k] = v
return core(d, npop)
def foo(n):
d = dictobject.new_dict(int32, float64)
for i in range(n):
d[i] = i + 1
# bad cast!?
z = d.get(2.4)
return z
def foo(n, target, default):
d = dictobject.new_dict(int32, float64)
# insertion loop
for i in range(n):
d[i] = i
# retrieval loop
return d.get(target, default)
def foo():
d = dictobject.new_dict(int32, float64)
e = d
d[1] = 12.
e[2] = 14.
e = dictobject.new_dict(int32, float64)
e[1] = 100.
e[2] = 1000.
f = d
d = e
k1 = [x for x in d.items()]
k2 = [x for x in e.items()]
k3 = [x for x in f.items()]
return k1, k2, k3
def foo(n):
d = dictobject.new_dict(int32, float64)
for i in range(n):
d[i] = i + 1
# bad default type
z = d.get(2 * n, 1j)
return z
def foo(keys, vals, target):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
# popitem
return d.pop(target, None), len(d)
def foo(keys, vals, target):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
# lookup
return d[target]
def foo(v1, v2):
d = dictobject.new_dict(int64, float64)
c1 = np.uint64(2 ** 61 - 1)
c2 = np.uint64(0)
assert hash(c1) == hash(c2)
d[c1] = v1
d[c2] = v2
return (d[c1], d[c2])
def foo(n):
d = dictobject.new_dict(int32, float64)
for i in range(n):
d[i] = i + 1
x = len(d)
d.clear()
y = len(d)
return x, y
def foo():
d = dictobject.new_dict(int32, float64)
def bar():
d[1] = 12.
d[2] = 14.
bar()
return [x for x in d.keys()]
def foo(keys, vals):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
b4 = len(d)
# clear
d.clear()
return b4, len(d)
def foo(keys, vals, checklist):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
out = []
for k in checklist:
out.append(k in d)
return out
def foo(keys, vals):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
out = []
for v in d.values():
out.append(v)
return out
def foo():
d = dictobject.new_dict(int32, float64)
d[11] = 12.
k1 = d.keys()
d[22] = 9.
k2 = d.keys()
rk1 = [x for x in k1]
rk2 = [x for x in k2]
return rk1, rk2
def foo():
d = dictobject.new_dict(types.unicode_type, float64)
tmp = []
for i in range(10000):
tmp.append('a')
s = ''.join(tmp)
d[s] = 1.
out = list(d.items())
return out
def foo(n, targets):
d = dictobject.new_dict(int32, float64)
# insertion loop
for i in range(n):
d[i] = i
# retrieval loop
output = []
for t in targets:
output.append(d.get(t))
return output
def foo():
d = dictobject.new_dict(int32, float64)
d.setdefault(1, 1.2) # used because key is not in
a = d.get(1)
d[1] = 2.3
b = d.get(1)
d[2] = 3.4
d.setdefault(2, 4.5) # not used because key is in
c = d.get(2)
return a, b, c
def foo():
d = dictobject.new_dict(types.unicode_type, float64)
d['a'] = 1.
d['b'] = 2.
d['c'] = 3.
d['d'] = 4.
out = []
for x in d.items():
out.append(x)
return out, d['a']
def foo(n):
d = dictobject.new_dict(int32, float64)
for i in range(n):
d[i] = i + 1
keys = []
vals = []
for i in range(n):
tmp = d.popitem()
keys.append(tmp[0])
vals.append(tmp[1])
return keys, vals
def foo():
d = dictobject.new_dict(int32, float64)
out = []
for kv in d.items():
out.append(kv)
return out
def foo():
d = dictobject.new_dict(int32, float64)
# popitem
return d.pop(0)
def foo():
d = dictobject.new_dict(int32, float64)
# default value is wrong type
d.setdefault(1, 12.j)
def foo():
d = dictobject.new_dict(int32, float64)
# not contains empty dict
return 1 not in d
def foo():
d = dictobject.new_dict(int32, float64)
d[0] = 6.
# invalid key type
return 1j in d
def foo():
d = dictobject.new_dict(int32, float64)
d[0] = 6.
d[1] = 7.
# pop'd default must have same type as value
d.pop(11, 12j)
def foo():
d = dictobject.new_dict(int32, float64)
# default value is wrong type
d.setdefault(1, 12.j)
def foo(na, b):
da = dictobject.new_dict(int32, float64)
for i in range(na):
da[i] = i
return da == b
def foo():
d = dictobject.new_dict(int32, float64)
d[0] = 6.
# invalid key type
return 1j in d
def foo():
d = dictobject.new_dict(int32, float64)
d[0] = 6.
d[1] = 7.
# pop'd key must have same type as key
d.pop(11j)
def foo():
d = dictobject.new_dict(int32, float64)
# not contains empty dict
return 1 not in d
def foo(n):
d = dictobject.new_dict(int32, float32)
for i in range(n):
d[i] = i + 1
return len(d)
def foo():
d = dictobject.new_dict(int32, float64)
# should raise TypingError
d[1] = 1j
def foo(keys, vals):
d = dictobject.new_dict(int32, float64)
# insertion
for k, v in zip(keys, vals):
d[k] = v
return list(d.copy().items())
def foo():
d = dictobject.new_dict(int32, float64)
# key is wrong type
d.setdefault(1j, 12.)
def boxer(nelem):
d = dictobject.new_dict(int32, float64)
for k, v in make_content(nelem):
d[k] = v
return dictobject._as_meminfo(d)
def foo():
d = dictobject.new_dict(int32, float64)
d[11] = 12.
d[22] = 9.
k2 = d.keys() & {12,}
return k2
def foo():
d = dictobject.new_dict(int32, float64)
# raise TypingError
d[11.5]
def _make_dict(keyty, valty):
return dictobject._as_meminfo(dictobject.new_dict(keyty, valty))
def foo():
d = dictobject.new_dict(int32, float64)
d[0] = 6.
d[1] = 7.
# pop'd key must have same type as key
d.pop(11j)
def impl(cls, key_type, value_type):
return dictobject.new_dict(key_type, value_type)
def foo():
d = dictobject.new_dict(int32, float64)
# contains on empty dict
return 1 in d
def foo():
d = dictobject.new_dict(int32, float64)
# contains on empty dict
return 1 in d
def foo():
d = dictobject.new_dict(int32, float64)
# key is wrong type
d.setdefault(1j, 12.)
def foo():
d = dictobject.new_dict(int32, float64)
d[11] = 12.
d[22] = 9.
k2 = d.keys() & {12,}
return k2