def test_double_jagged():
array = awkward1.Array([[[0, 1, 2, 3], [4, 5]], [[6, 7, 8], [9, 10, 11, 12, 13]]], check_valid=True)
assert awkward1.to_list(array[awkward1.Array([[[2, 1, 0], [-1]], [[-1, -2, -3], [2, 1, 1, 3]]], check_valid=True)]) == [[[2, 1, 0], [5]], [[8, 7, 6], [11, 10, 10, 12]]]
content = awkward1.from_iter([[0, 1, 2, 3], [4, 5], [6, 7, 8], [9, 10, 11, 12, 13]], highlevel=False)
regulararray = awkward1.layout.RegularArray(content, 2)
assert awkward1.to_list(regulararray[:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[2, 1, 0], [5]], [[8, 7, 6], [13]]]
assert awkward1.to_list(regulararray[1:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[8, 7, 6], [13]]]
offsets = awkward1.layout.Index64(numpy.array([0, 2, 4], dtype=numpy.int64))
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, content)
assert awkward1.to_list(listoffsetarray[:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[2, 1, 0], [5]], [[8, 7, 6], [13]]]
assert awkward1.to_list(listoffsetarray[1:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[8, 7, 6], [13]]]
def test_Record_getitem():
record = awkward1.Array([{
"x": 0.0,
"y": []
}, {
"x": 1.1,
"y": [1]
}, {
"x": 2.2,
"y": [2, 2]
}, {
"x": 3.3,
"y": [3, 3, 3]
}, {
"x": 4.4,
"y": [4, 4, 4, 4]
}],
check_valid=True)[3]
@numba.njit
def f1(x):
return x["x"]
assert f1(record) == 3.3
@numba.njit
def f2(x):
return x["y"]
assert awkward1.to_list(f2(record)) == [3, 3, 3]
@numba.njit
def f3(x):
return x.x
assert f3(record) == 3.3
@numba.njit
def f4(x):
return x.y
assert awkward1.to_list(f4(record)) == [3, 3, 3]
def test_RecordArray_getitem_field():
array = awkward1.Array([{
"x": 0.0,
"y": []
}, {
"x": 1.1,
"y": [1]
}, {
"x": 2.2,
"y": [2, 2]
}, {
"x": 3.3,
"y": [3, 3, 3]
}, {
"x": 4.4,
"y": [4, 4, 4, 4]
}],
check_valid=True)
@numba.njit
def f1(x):
return x[1:4]["x"]
assert awkward1.to_list(f1(array)) == [1.1, 2.2, 3.3]
@numba.njit
def f2(x):
return x[1:4]["y"]
assert awkward1.to_list(f2(array)) == [[1], [2, 2], [3, 3, 3]]
@numba.njit
def f3(x):
return x[1:4].x
assert awkward1.to_list(f3(array)) == [1.1, 2.2, 3.3]
@numba.njit
def f4(x):
return x[1:4].y
assert awkward1.to_list(f4(array)) == [[1], [2, 2], [3, 3, 3]]
def test_numpyarray():
layout = awkward1.from_iter(
[0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9], highlevel=False)
numbatype = awkward1._connect._numba.arrayview.tonumbatype(layout.form)
assert numba.typeof(layout).name == numbatype.name
lookup1 = awkward1_connect_numba_arrayview.Lookup(layout)
lookup2 = awkward1_connect_numba_arrayview.Lookup(layout.form)
numbatype.form_fill(0, layout, lookup2)
assert numpy.array_equal(lookup1.arrayptrs, lookup2.arrayptrs)
assert numpy.array_equal(lookup1.sharedptrs == -1,
lookup2.sharedptrs == -1)
counter = [0]
def materialize():
counter[0] += 1
return layout
generator = awkward1.layout.ArrayGenerator(materialize,
form=layout.form,
length=len(layout))
virtualarray = awkward1.layout.VirtualArray(generator)
lookup3 = awkward1_connect_numba_arrayview.Lookup(virtualarray)
assert len(lookup1.arrayptrs) + 3 == len(lookup3.arrayptrs)
array = awkward1.Array(virtualarray)
array.numba_type
assert counter[0] == 0
@numba.njit
def f1(x):
return x[5]
assert f1(array) == 5.5
assert counter[0] == 1
assert f1(array) == 5.5
assert counter[0] == 1
def test_ArrayBuilder_append_numba3():
@numba.njit
def f1(array, builder):
builder.extend(array[3])
builder.extend(array[2])
builder.extend(array[2])
builder.extend(array[0])
builder.extend(array[1])
builder.extend(array[-1])
array = awkward1.Array(
[[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]],
check_valid=True)
builder = awkward1.ArrayBuilder()
f1(array, builder)
assert awkward1.to_list(builder.snapshot()) == [
5.5, 3.3, 4.4, 3.3, 4.4, 0.0, 1.1, 2.2, 6.6, 7.7, 8.8, 9.9
]
def test_ListArray_getitem():
array = awkward1.Array(
[[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]],
check_valid=True)
@numba.njit
def f1(x, i):
return x[i]
assert awkward1.to_list(f1(array, 0)) == [0.0, 1.1, 2.2]
assert awkward1.to_list(f1(array, 1)) == []
assert awkward1.to_list(f1(array, 2)) == [3.3, 4.4]
assert awkward1.to_list(f1(array, 3)) == [5.5]
assert awkward1.to_list(f1(array, 4)) == [6.6, 7.7, 8.8, 9.9]
@numba.njit
def f2(x, i1, i2):
return x[i1:i2]
assert awkward1.to_list(f2(array, 1, 4)) == [[], [3.3, 4.4], [5.5]]
def test_list_array():
array = awkward1.Array(numpy.arange(3*5*2).reshape(3, 5, 2).tolist())
assert awkward1.num(array, axis=0) == 3
assert awkward1.num(array, axis=1) == [5, 5, 5]
assert awkward1.num(array, axis=2) == [[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2]]
with pytest.raises(ValueError) as err:
assert awkward1.num(array, axis=3)
assert str(err.value) == "'axis' out of range for 'num'"
assert awkward1.num(array, axis=-1) == [5, 5, 5]
assert awkward1.num(array, axis=-2) == [[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2]]
assert awkward1.num(array, axis=-3) == 3
with pytest.raises(ValueError) as err:
assert awkward1.num(array, axis=-4)
assert str(err.value) == "axis == -4 exceeds the depth == 3 of this array"
def test_regular_deep():
regular = awkward1.Array(numpy.array([[[i, i, i], [i, i, i]] for i in range(10)], dtype=numpy.int64))
assert str(regular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=1)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * var * 3 * int64"
reregular = awkward1.to_regular(irregular, axis=1)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=2)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * 2 * var * int64"
reregular = awkward1.to_regular(irregular, axis=2)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=-1)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * 2 * var * int64"
reregular = awkward1.to_regular(irregular, axis=-1)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=-2)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * var * 3 * int64"
reregular = awkward1.to_regular(irregular, axis=-2)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
with pytest.raises(ValueError):
awkward1.from_regular(regular, axis=-3)
assert awkward1.to_list(awkward1.from_regular(regular, axis=0)) == awkward1.to_list(regular)
assert awkward1.type(awkward1.from_regular(regular, axis=0)) == awkward1.type(regular)
def test():
array = awkward1.Array([{
"x": "one"
}, {
"x": "two"
}, {
"x": "three"
}],
check_valid=True)
assert awkward1.to_list(array) == [{
"x": "one"
}, {
"x": "two"
}, {
"x": "three"
}]
assert awkward1.to_list(awkward1.from_iter(awkward1.to_list(array))) == [{
"x":
"one"
}, {
"x":
"two"
}, {
"x":
"three"
}]
assert awkward1.to_list(array.layout) == [{
"x": "one"
}, {
"x": "two"
}, {
"x": "three"
}]
assert awkward1.to_list(awkward1.from_iter(awkward1.to_list(
array.layout))) == [{
"x": "one"
}, {
"x": "two"
}, {
"x": "three"
}]
def test_ListArray_deep_at():
content = awkward1.layout.NumpyArray(
numpy.array([
1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0, 11.1, 12.2,
13.3, 14.4, 15.5, 16.6, 17.7, 18.8, 19.9
]))
offsets1 = awkward1.layout.Index32(
numpy.array([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], dtype=numpy.int32))
listarray1 = awkward1.layout.ListOffsetArray32(offsets1, content)
offsets2 = awkward1.layout.Index64(
numpy.array([0, 2, 4, 6, 8], dtype=numpy.int64))
listarray2 = awkward1.layout.ListOffsetArray64(offsets2, listarray1)
offsets3 = awkward1.layout.Index32(
numpy.array([0, 2, 4], dtype=numpy.int32))
listarray3 = awkward1.layout.ListOffsetArray32(offsets3, listarray2)
array = awkward1.Array(listarray3, check_valid=True)
@numba.njit
def f1(x):
return x[1][1][1][1]
assert f1(array) == 16.6
@numba.njit
def f2(x):
return x[1][1][1]
assert awkward1.to_list(f2(array)) == [15.5, 16.6]
@numba.njit
def f3(x):
return x[1][1]
assert awkward1.to_list(f3(array)) == [[13.3, 14.4], [15.5, 16.6]]
@numba.njit
def f4(x):
return x[1]
assert awkward1.to_list(f4(array)) == [[[9.9, 10.0], [11.1, 12.2]],
[[13.3, 14.4], [15.5, 16.6]]]
def test_nested_virtualness():
counter = [0, 0]
content = awkward1.layout.NumpyArray(
numpy.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]))
def materialize1():
counter[1] += 1
return content
generator1 = awkward1.layout.ArrayGenerator(materialize1,
form=content.form,
length=len(content))
virtual1 = awkward1.layout.VirtualArray(generator1)
offsets = awkward1.layout.Index64(
numpy.array([0, 3, 3, 5, 6, 10], dtype=numpy.int64))
listarray = awkward1.layout.ListOffsetArray64(offsets, virtual1)
def materialize2():
counter[0] += 1
return listarray
generator2 = awkward1.layout.ArrayGenerator(materialize2,
form=listarray.form,
length=len(listarray))
virtual2 = awkward1.layout.VirtualArray(generator2)
array = awkward1.Array(virtual2)
assert counter == [0, 0]
@numba.njit
def f1(x, i):
return x[i]
tmp1 = f1(array, 2)
assert counter == [1, 0]
tmp2 = f1(tmp1, 1)
assert tmp2 == 4.4
assert counter == [1, 1]
def _apply_global_index(self, index):
"""Internal method to take from a collection using a flat index
This is often necessary to be able to still resolve cross-references on
reduced arrays or single records.
"""
if isinstance(index, int):
out = self._content()[index]
return awkward1.Record(out, behavior=self.behavior)
def flat_take(layout):
idx = awkward1.Array(layout)
return self._content()[idx.mask[idx >= 0]]
def descend(layout, depth):
if layout.purelist_depth == 1:
return lambda: flat_take(layout)
(index, ) = awkward1.broadcast_arrays(index)
out = awkward1._util.recursively_apply(index.layout, descend)
return awkward1.Array(out, behavior=self.behavior)
def test_custom_record4():
behavior = {}
behavior["__numba_typer__", "Dummy", operator.add, "Dummy"] = dummy_typer4
behavior["__numba_lower__", "Dummy", operator.add, "Dummy"] = dummy_lower4
behavior["__numba_typer__", "Dummy", operator.eq, "Dummy"] = dummy_typer4
behavior["__numba_lower__", "Dummy", operator.eq, "Dummy"] = dummy_lower4
array = awkward1.Array([{"x": 1.1, "y": 100}, {"x": 2.2, "y": 200}, {"x": 3.3, "y": 300}], behavior=behavior, check_valid=True)
array.layout.setparameter("__record__", "Dummy")
@numba.njit
def f1(x, i, j):
return x[i] + x[j]
assert f1(array, 1, 2) == 5.5
@numba.njit
def f2(x, i, j):
return x[i] == x[j]
assert f2(array, 1, 2) == 5.5
def test_ArrayBuilder_append_numba():
@numba.njit
def f1(array, builder):
builder.append(array, 3)
builder.append(array, 2)
builder.append(array, 2)
builder.append(array, 0)
builder.append(array, 1)
builder.append(array, -1)
array = awkward1.Array(
[[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]],
check_valid=True)
builder = awkward1.ArrayBuilder()
f1(array, builder)
assert awkward1.to_list(builder.snapshot()) == [[5.5], [3.3, 4.4],
[3.3, 4.4],
[0.0, 1.1, 2.2], [],
[6.6, 7.7, 8.8, 9.9]]
def test_record_array_axis_out_of_range():
array = awkward1.Array([{
"x": [1],
"y": [[], [1]]
}, {
"x": [1, 2],
"y": [[], [1], [1, 2]]
}, {
"x": [1, 2, 3],
"y": [[], [1], [1, 2], [1, 2, 3]]
}])
with pytest.raises(ValueError) as err:
assert awkward1.num(array, axis=-2)
assert str(err.value).startswith(
"axis == -2 exceeds the min depth == 2 of this array")
with pytest.raises(ValueError) as err:
assert awkward1.num(array, axis=-3)
assert str(err.value).startswith(
"axis == -3 exceeds the depth == 2 of this array")
def nestedindex(stack):
"""Concatenate a list of indices along a new axis
Signature: index1,index2,...,!nestedindex
Index arrays should all be same shape flat arrays
Outputs a jagged array with same outer shape as index arrays
"""
indexers = stack[:]
stack.clear()
# return awkward1.concatenate([idx[:, None] for idx in indexers], axis=1)
n = len(indexers)
out = numpy.empty(n * len(indexers[0]), dtype="int64")
for i, idx in enumerate(indexers):
out[i::n] = idx
offsets = numpy.arange(0, len(out) + 1, n, dtype=numpy.int64)
out = awkward1.Array(
awkward1.layout.ListOffsetArray64(
awkward1.layout.Index64(offsets),
awkward1.layout.NumpyArray(out),
))
stack.append(out)
def test_repartition():
array = awkward1.Array([[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []])
array2 = awkward1.repartition(array, 2)
array3 = awkward1.repartition(array, 3)
array4 = awkward1.repartition(array, [3, 2, 3, 1])
array5 = awkward1.repartition(array2, None)
assert isinstance(array.layout, awkward1.layout.Content)
assert isinstance(array2.layout, awkward1.partition.PartitionedArray)
assert isinstance(array3.layout, awkward1.partition.PartitionedArray)
assert isinstance(array4.layout, awkward1.partition.PartitionedArray)
assert isinstance(array5.layout, awkward1.layout.Content)
assert awkward1.to_list(array) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []]
assert awkward1.to_list(array2) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []]
assert awkward1.to_list(array3) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []]
assert awkward1.to_list(array4) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []]
assert awkward1.to_list(array5) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []]
assert [awkward1.to_list(x) for x in array2.layout.partitions] == [[[], [1.1, 2.2, 3.3]], [[], []], [[4.4, 5.5], []], [[6.6], [7.7, 8.8, 9.9]], [[]]]
assert [awkward1.to_list(x) for x in array3.layout.partitions] == [[[], [1.1, 2.2, 3.3], []], [[], [4.4, 5.5], []], [[6.6], [7.7, 8.8, 9.9], []]]
assert [awkward1.to_list(x) for x in array4.layout.partitions] == [[[], [1.1, 2.2, 3.3], []], [[], [4.4, 5.5]], [[], [6.6], [7.7, 8.8, 9.9]], [[]]]
def test_0459():
plain_plain = awkward1.Array([0.0, 1.1, 2.2, 3.3, 4.4])
array_plain = awkward1.with_parameter(plain_plain, "__array__", "zoinks")
plain_isdoc = awkward1.with_parameter(plain_plain, "__doc__", "This is a zoink.")
array_isdoc = awkward1.with_parameter(array_plain, "__doc__", "This is a zoink.")
assert awkward1.parameters(plain_plain) == {}
assert awkward1.parameters(array_plain) == {"__array__": "zoinks"}
assert awkward1.parameters(plain_isdoc) == {"__doc__": "This is a zoink."}
assert awkward1.parameters(array_isdoc) == {"__array__": "zoinks", "__doc__": "This is a zoink."}
assert awkward1.parameters(awkward1.concatenate([plain_plain, plain_plain])) == {}
assert awkward1.parameters(awkward1.concatenate([array_plain, array_plain])) == {"__array__": "zoinks"}
assert awkward1.parameters(awkward1.concatenate([plain_isdoc, plain_isdoc])) == {"__doc__": "This is a zoink."}
assert awkward1.parameters(awkward1.concatenate([array_isdoc, array_isdoc])) == {"__array__": "zoinks", "__doc__": "This is a zoink."}
assert isinstance(awkward1.concatenate([plain_plain, plain_plain]).layout, awkward1.layout.NumpyArray)
assert isinstance(awkward1.concatenate([array_plain, array_plain]).layout, awkward1.layout.NumpyArray)
assert isinstance(awkward1.concatenate([plain_isdoc, plain_isdoc]).layout, awkward1.layout.NumpyArray)
assert isinstance(awkward1.concatenate([array_isdoc, array_isdoc]).layout, awkward1.layout.NumpyArray)
assert awkward1.parameters(awkward1.concatenate([plain_plain, array_plain])) == {}
assert awkward1.parameters(awkward1.concatenate([plain_isdoc, array_isdoc])) == {}
assert awkward1.parameters(awkward1.concatenate([array_plain, plain_plain])) == {}
assert awkward1.parameters(awkward1.concatenate([array_isdoc, plain_isdoc])) == {}
assert isinstance(awkward1.concatenate([plain_plain, array_plain]).layout, awkward1.layout.UnionArray8_64)
assert isinstance(awkward1.concatenate([plain_isdoc, array_isdoc]).layout, awkward1.layout.UnionArray8_64)
assert isinstance(awkward1.concatenate([array_plain, plain_plain]).layout, awkward1.layout.UnionArray8_64)
assert isinstance(awkward1.concatenate([array_isdoc, plain_isdoc]).layout, awkward1.layout.UnionArray8_64)
assert awkward1.parameters(awkward1.concatenate([plain_plain, plain_isdoc])) == {}
assert awkward1.parameters(awkward1.concatenate([array_plain, array_isdoc])) == {"__array__": "zoinks"}
assert awkward1.parameters(awkward1.concatenate([plain_isdoc, plain_plain])) == {}
assert awkward1.parameters(awkward1.concatenate([array_isdoc, array_plain])) == {"__array__": "zoinks"}
assert isinstance(awkward1.concatenate([plain_plain, plain_isdoc]).layout, awkward1.layout.NumpyArray)
assert isinstance(awkward1.concatenate([array_plain, array_isdoc]).layout, awkward1.layout.NumpyArray)
assert isinstance(awkward1.concatenate([plain_isdoc, plain_plain]).layout, awkward1.layout.NumpyArray)
assert isinstance(awkward1.concatenate([array_isdoc, array_plain]).layout, awkward1.layout.NumpyArray)
def test_IndexedArray_getitem():
content = awkward1.from_iter(
[0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9], highlevel=False)
index = awkward1.layout.Index64(
numpy.array([3, 2, 2, 5, 0, 7], dtype=numpy.int64))
array = awkward1.Array(awkward1.layout.IndexedArray64(index, content),
check_valid=True)
@numba.njit
def f1(x, i):
return x[i]
assert [f1(array, 0),
f1(array, 1),
f1(array, 2),
f1(array, 3)] == [3.3, 2.2, 2.2, 5.5]
@numba.njit
def f2(x, i1, i2):
return x[i1:i2]
assert awkward1.to_list(f2(array, 1, 5)) == [2.2, 2.2, 5.5, 0]
def test():
behavior = {}
behavior["__typestr__", "Point"] = "P"
behavior["Point"] = Point
array = awkward1.Array([[{
"x": 1,
"y": [1.1]
}, {
"x": 2,
"y": [2.0, 0.2]
}], [], [{
"x": 3,
"y": [3.0, 0.3, 3.3]
}]],
with_name="Point",
behavior=behavior,
check_valid=True)
assert repr(array[0, 0]) == "<1 [1.1]>"
assert repr(array[0]) == "<Array [<1 [1.1]>, <2 [2, 0.2]>] type='2 * P'>"
assert repr(
array
) == "<Array [[<1 [1.1]>, ... <3 [3, 0.3, 3.3]>]] type='3 * var * P'>"
def test_size():
assert awkward1.size(awkward1.Array([1.1, 2.2, 3.3, 4.4, 5.5], check_valid=True)) == 5
assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True)) == 30
assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True), 0) == 2
assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True), 1) == 3
assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True), 2) == 5
assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5))) == 30
assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5)), 0) == 2
assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5)), 1) == 3
assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5)), 2) == 5
assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5)) == 30
assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5), 0) == 2
assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5), 1) == 3
assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5), 2) == 5
with pytest.raises(ValueError) as err:
awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5).tolist(), check_valid=True))
assert str(err.value).startswith("ak.size is ambiguous due to variable-length arrays (try ak.flatten to remove structure or ak.to_numpy to force regularity, if possible)")
def test_UnmaskedArray():
content_float64 = awkward1.layout.NumpyArray(numpy.array([0.25, 0.5, 3.5, 4.5, 5.5], dtype=numpy.float64))
array_float64 = awkward1.layout.UnmaskedArray(content_float64)
assert awkward1.to_list(array_float64) == [0.25, 0.5, 3.5, 4.5, 5.5]
assert str(awkward1.type(content_float64)) == "float64"
assert str(awkward1.type(awkward1.Array(content_float64))) == "5 * float64"
assert str(awkward1.type(array_float64)) == "?float64"
assert str(awkward1.type(awkward1.Array(array_float64))) == "5 * ?float64"
assert numpy.can_cast(numpy.float32, numpy.float64) == True
assert numpy.can_cast(numpy.float64, numpy.float32, 'unsafe') == True
assert numpy.can_cast(numpy.float64, numpy.int8, 'unsafe') == True
content_float32 = awkward1.values_astype(content_float64, 'float32', highlevel=False)
array_float32 = awkward1.layout.UnmaskedArray(content_float32)
assert awkward1.to_list(array_float32) == [0.25, 0.5, 3.5, 4.5, 5.5]
assert str(awkward1.type(content_float32)) == "float32"
assert str(awkward1.type(awkward1.Array(content_float32))) == "5 * float32"
assert str(awkward1.type(array_float32)) == "?float32"
assert str(awkward1.type(awkward1.Array(array_float32))) == "5 * ?float32"
content_int8 = awkward1.values_astype(content_float64, 'int8', highlevel=False)
array_int8 = awkward1.layout.UnmaskedArray(content_int8)
assert awkward1.to_list(array_int8) == [0, 0, 3, 4, 5]
assert str(awkward1.type(content_int8)) == "int8"
assert str(awkward1.type(awkward1.Array(content_int8))) == "5 * int8"
assert str(awkward1.type(array_int8)) == "?int8"
assert str(awkward1.type(awkward1.Array(array_int8))) == "5 * ?int8"
content_from_int8 = awkward1.values_astype(content_int8, 'float64', highlevel=False)
array_from_int8 = awkward1.layout.UnmaskedArray(content_from_int8)
assert awkward1.to_list(array_from_int8) == [0, 0, 3, 4, 5]
assert str(awkward1.type(content_from_int8)) == "float64"
assert str(awkward1.type(awkward1.Array(content_from_int8))) == "5 * float64"
assert str(awkward1.type(array_from_int8)) == "?float64"
assert str(awkward1.type(awkward1.Array(array_from_int8))) == "5 * ?float64"
def test():
content = awkward1.Array([1, 2, 3, 4, 5])
generator1 = awkward1.layout.ArrayGenerator(lambda a, b: a * content + b,
(100, ), {"b": 3})
assert awkward1.to_list(generator1()) == [103, 203, 303, 403, 503]
assert generator1.args == (100, )
assert generator1.kwargs == {"b": 3}
assert generator1.form is None
assert generator1.length is None
generator2 = generator1.with_args((1000, ))
assert awkward1.to_list(generator2()) == [1003, 2003, 3003, 4003, 5003]
assert generator2.args == (1000, )
assert generator2.kwargs == {"b": 3}
assert generator2.form is None
assert generator2.length is None
generator3 = generator1.with_kwargs({"b": 4})
assert awkward1.to_list(generator3()) == [104, 204, 304, 404, 504]
assert generator3.args == (100, )
assert generator3.kwargs == {"b": 4}
assert generator3.form is None
assert generator3.length is None
generator4 = generator1.with_form(awkward1.forms.Form.fromjson('"int64"'))
assert awkward1.to_list(generator4()) == [103, 203, 303, 403, 503]
assert generator4.args == (100, )
assert generator4.kwargs == {"b": 3}
assert json.loads(generator4.form.tojson()) == json.loads(
awkward1.forms.Form.fromjson('"int64"').tojson())
assert generator4.length is None
generator5 = generator1.with_length(5)
assert awkward1.to_list(generator5()) == [103, 203, 303, 403, 503]
assert generator5.args == (100, )
assert generator5.kwargs == {"b": 3}
assert generator5.form is None
assert generator5.length == 5
def test():
example = awkward1.Array([[{"x": 1, "y": []}, {"x": 2, "y": [1, 1]}], []])
cache = {}
virtualarray = awkward1.virtual(lambda: example,
form=example.layout.form,
length=len(example))
assert len(cache) == 0
tmp1 = virtualarray["x"]
assert json.loads(str(tmp1.layout.form)) == {
"class": "VirtualArray",
"form": {
"class": "ListOffsetArray64",
"offsets": "i64",
"content": "int64"
},
"has_length": True
}
assert len(cache) == 0
tmp2 = virtualarray["y"]
assert json.loads(str(tmp2.layout.form)) == {
"class": "VirtualArray",
"form": {
"class": "ListOffsetArray64",
"offsets": "i64",
"content": {
"class": "ListOffsetArray64",
"offsets": "i64",
"content": "int64"
}
},
"has_length": True
}
assert len(cache) == 0
assert tmp1.tolist() == [[1, 2], []]
assert tmp2.tolist() == [[[], [1, 1]], []]
def test_custom_record5():
behavior = {}
behavior["__numba_typer__", abs, "Dummy"] = dummy_typer5
behavior["__numba_lower__", abs, "Dummy"] = dummy_lower5
behavior["__numba_typer__", operator.neg, "Dummy"] = dummy_typer5
behavior["__numba_lower__", operator.neg, "Dummy"] = dummy_lower5
array = awkward1.Array([{"x": 1.1, "y": 100}, {"x": -2.2, "y": 200}, {"x": 3.3, "y": 300}], behavior=behavior, check_valid=True)
array.layout.setparameter("__record__", "Dummy")
@numba.njit
def f1(x, i):
return abs(x[i])
assert f1(array, 1) == 2.2
assert f1(array, 2) == 3.3
@numba.njit
def f2(x, i):
return -x[i]
assert f2(array, 1) == 2.2
assert f2(array, 2) == 3.3
def test_flat():
grad_tanh = awkward1.autograd.elementwise_grad(tanh)
xs = awkward1.Array(numpy.linspace(-3, 3, 10), check_valid=True)
assert awkward1.to_list(xs) == pytest.approx([
-3.0, -2.3333333333333335, -1.6666666666666667, -1.0,
-0.3333333333333335, 0.33333333333333304, 1.0, 1.666666666666666,
2.333333333333333, 3.0
])
assert awkward1.to_list(tanh(xs)) == pytest.approx([
-0.9950547536867305, -0.9813680813098666, -0.9311096086675776,
-0.7615941559557649, -0.32151273753163445, 0.32151273753163406,
0.7615941559557649, 0.9311096086675775, 0.9813680813098666,
0.9950547536867306
])
assert awkward1.to_list(grad_tanh(xs)) == pytest.approx([
0.009866037165439843, 0.036916688986191167, 0.1330348966469106,
0.4199743416140259, 0.8966295596049142, 0.8966295596049146,
0.419974341614026, 0.13303489664691054, 0.03691668898619103,
0.009866037165440192
])
def test_IndexedOptionArray_combinations():
content = awkward1.from_iter([[[0, 1, 2], [], [3, 4]], [], [[5]],
[[6, 7, 8, 9]], [[], [10, 11, 12]]],
highlevel=False)
index = awkward1.layout.Index64(
numpy.array([0, 1, -1, -1, 4], dtype=numpy.int64))
array = awkward1.Array(awkward1.layout.IndexedOptionArray64(
index, content))
assert awkward1.to_list(array) == [[[0, 1, 2], [], [3, 4]], [], None, None,
[[], [10, 11, 12]]]
assert awkward1.to_list(awkward1.combinations(array, 2, axis=0)) == [
([[0, 1, 2], [], [3, 4]], []), ([[0, 1, 2], [], [3, 4]], None),
([[0, 1, 2], [], [3, 4]], None),
([[0, 1, 2], [], [3, 4]], [[], [10, 11, 12]]), ([], None), ([], None),
([], [[], [10, 11, 12]]), (None, None), (None, [[], [10, 11, 12]]),
(None, [[], [10, 11, 12]])
]
assert awkward1.to_list(awkward1.combinations(array, 2, axis=1)) == [[
([0, 1, 2], []), ([0, 1, 2], [3, 4]), ([], [3, 4])
], [], None, None, [([], [10, 11, 12])]]
assert awkward1.to_list(awkward1.combinations(array, 2, axis=2)) == [[[
(0, 1), (0, 2), (1, 2)
], [], [(3, 4)]], [], None, None, [[], [(10, 11), (10, 12), (11, 12)]]]
def test_array_3d():
array = awkward1.Array(numpy.arange(3*5*2).reshape(3, 5, 2))
assert awkward1.to_list(array) == [[[ 0, 1], [ 2, 3], [ 4, 5], [ 6, 7], [ 8, 9]],
[[10, 11], [12, 13], [14, 15], [16, 17], [18, 19]],
[[20, 21], [22, 23], [24, 25], [26, 27], [28, 29]]]
assert awkward1.num(array, axis=0) == 3
assert awkward1.to_list(awkward1.num(array, axis=1)) == [5, 5, 5]
assert awkward1.to_list(awkward1.num(array, axis=2)) == [[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2]]
with pytest.raises(ValueError) as err:
assert awkward1.num(array, axis=3)
assert str(err.value) == "'axis' out of range for 'num'"
assert awkward1.to_list(awkward1.num(array, axis=-1)) == [[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2],
[2, 2, 2, 2, 2]]
assert awkward1.to_list(awkward1.num(array, axis=-2)) == [5, 5, 5]
assert awkward1.num(array, axis=-3) == 3
with pytest.raises(ValueError) as err:
assert awkward1.num(array, axis=-4)
assert str(err.value) == "axis == -4 exceeds the depth == 3 of this array"
def test_refcount():
array = awkward1.Array([1, 2, 3])
@numba.njit
def f1():
array
return 3.14
@numba.njit
def f2():
array, array
return 3.14
assert sys.getrefcount(array) == 2
f1()
assert sys.getrefcount(array) == 3
f2()
assert sys.getrefcount(array) == 5
del f1
assert sys.getrefcount(array) == 4
del f2
assert sys.getrefcount(array) == 2
def test_ByteMaskedArray_combinations():
content = awkward1.from_iter([[[0, 1, 2], [], [3, 4]], [], [[5]],
[[6, 7, 8, 9]], [[], [10, 11, 12]]],
highlevel=False)
mask = awkward1.layout.Index8(
numpy.array([0, 0, 1, 1, 0], dtype=numpy.int8))
array = awkward1.Array(
awkward1.layout.ByteMaskedArray(mask, content, valid_when=False))
assert awkward1.to_list(array) == [[[0, 1, 2], [], [3, 4]], [], None, None,
[[], [10, 11, 12]]]
assert awkward1.to_list(awkward1.combinations(array, 2, axis=0)) == [
([[0, 1, 2], [], [3, 4]], []), ([[0, 1, 2], [], [3, 4]], None),
([[0, 1, 2], [], [3, 4]], None),
([[0, 1, 2], [], [3, 4]], [[], [10, 11, 12]]), ([], None), ([], None),
([], [[], [10, 11, 12]]), (None, None), (None, [[], [10, 11, 12]]),
(None, [[], [10, 11, 12]])
]
assert awkward1.to_list(awkward1.combinations(array, 2, axis=1)) == [[
([0, 1, 2], []), ([0, 1, 2], [3, 4]), ([], [3, 4])
], [], None, None, [([], [10, 11, 12])]]
assert awkward1.to_list(awkward1.combinations(array, 2, axis=2)) == [[[
(0, 1), (0, 2), (1, 2)
], [], [(3, 4)]], [], None, None, [[], [(10, 11), (10, 12), (11, 12)]]]
