Kernel interface and specification#
All array manipulation that is not performed by NumPy/CuPy/etc. is executed in Awkward Array’s low-level “kernels.” These functions communicate entirely by side-effects, manipulating already-allocated arrays, and therefore can be implemented with a pure C interface. They’re called “kernels” because their signatures are similar to GPU kernels, to make them easier to port to GPUs and similar devices.
All of the kernel functions that Awkward Array uses are documented below. These are internal details of Awkward Array, subject to change at any time, not a public API. The reason that we are documenting the API is to ensure compatibility between the primary CPU-bound kernels and their equivalents, ported to GPUs (and similar devices). The definitions below are expressed in Python code, but the implementations used by Awkward Array are compiled.
awkward_BitMaskedArray_to_ByteMaskedArray#
- awkward_BitMaskedArray_to_ByteMaskedArray(tobytemask: List[int8_t], frombitmask: Const[List[uint8_t]], bitmasklength: int64_t, validwhen: bool, lsb_order: bool)#
def awkward_BitMaskedArray_to_ByteMaskedArray(
tobytemask, frombitmask, bitmasklength, validwhen, lsb_order
):
if lsb_order:
for i in range(bitmasklength):
byte = frombitmask[i]
tobytemask[(i * 8) + 0] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 1] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 2] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 3] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 4] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 5] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 6] = (byte & uint8(1)) != validwhen
byte >>= 1
tobytemask[(i * 8) + 7] = (byte & uint8(1)) != validwhen
else:
for i in range(bitmasklength):
byte = frombitmask[i]
tobytemask[(i * 8) + 0] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 1] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 2] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 3] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 4] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 5] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 6] = ((byte & uint8(128)) != 0) != validwhen
byte = (byte << 1) & 0xFF
tobytemask[(i * 8) + 7] = ((byte & uint8(128)) != 0) != validwhen
awkward_BitMaskedArray_to_IndexedOptionArray#
- awkward_BitMaskedArray_to_IndexedOptionArray64(toindex: List[int64_t], frombitmask: Const[List[uint8_t]], bitmasklength: int64_t, validwhen: bool, lsb_order: bool)#
def awkward_BitMaskedArray_to_IndexedOptionArray(
toindex, frombitmask, bitmasklength, validwhen, lsb_order
):
if lsb_order:
for i in range(bitmasklength):
byte = frombitmask[i]
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 0] = (i * 8) + 0
else:
toindex[(i * 8) + 0] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 1] = (i * 8) + 1
else:
toindex[(i * 8) + 1] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 2] = (i * 8) + 2
else:
toindex[(i * 8) + 2] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 3] = (i * 8) + 3
else:
toindex[(i * 8) + 3] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 4] = (i * 8) + 4
else:
toindex[(i * 8) + 4] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 5] = (i * 8) + 5
else:
toindex[(i * 8) + 5] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 6] = (i * 8) + 6
else:
toindex[(i * 8) + 6] = -1
byte >>= 1
if (byte & uint8(1)) == validwhen:
toindex[(i * 8) + 7] = (i * 8) + 7
else:
toindex[(i * 8) + 7] = -1
else:
for i in range(bitmasklength):
byte = frombitmask[i]
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 0] = (i * 8) + 0
else:
toindex[(i * 8) + 0] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 1] = (i * 8) + 1
else:
toindex[(i * 8) + 1] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 2] = (i * 8) + 2
else:
toindex[(i * 8) + 2] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 3] = (i * 8) + 3
else:
toindex[(i * 8) + 3] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 4] = (i * 8) + 4
else:
toindex[(i * 8) + 4] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 5] = (i * 8) + 5
else:
toindex[(i * 8) + 5] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 6] = (i * 8) + 6
else:
toindex[(i * 8) + 6] = -1
byte = (byte << 1) & 0xFF
if ((byte & uint8(128)) != 0) == validwhen:
toindex[(i * 8) + 7] = (i * 8) + 7
else:
toindex[(i * 8) + 7] = -1
awkward_ByteMaskedArray_getitem_nextcarry#
- awkward_ByteMaskedArray_getitem_nextcarry_64(tocarry: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)#
def awkward_ByteMaskedArray_getitem_nextcarry(tocarry, mask, length, validwhen):
k = 0
for i in range(length):
if (mask[i] != 0) == validwhen:
tocarry[k] = i
k = k + 1
awkward_ByteMaskedArray_getitem_nextcarry_outindex#
- awkward_ByteMaskedArray_getitem_nextcarry_outindex_64(tocarry: List[int64_t], outindex: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)#
def awkward_ByteMaskedArray_getitem_nextcarry_outindex(
tocarry, outindex, mask, length, validwhen
):
k = 0
for i in range(length):
if (mask[i] != 0) == validwhen:
tocarry[k] = i
outindex[i] = k
k = k + 1
else:
outindex[i] = -1
awkward_ByteMaskedArray_numnull#
- awkward_ByteMaskedArray_numnull(numnull: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)#
def awkward_ByteMaskedArray_numnull(numnull, mask, length, validwhen):
numnull[0] = 0
for i in range(length):
if (mask[i] != 0) != validwhen:
numnull[0] = numnull[0] + 1
awkward_ByteMaskedArray_overlay_mask#
- awkward_ByteMaskedArray_overlay_mask8(tomask: List[int8_t], theirmask: Const[List[int8_t]], mymask: Const[List[int8_t]], length: int64_t, validwhen: bool)#
def awkward_ByteMaskedArray_overlay_mask(tomask, theirmask, mymask, length, validwhen):
for i in range(length):
theirs = theirmask[i]
mine = (mymask[i] != 0) != validwhen
tomask[i] = 1 if theirs | mine else 0
awkward_ByteMaskedArray_reduce_next_64#
- awkward_ByteMaskedArray_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], mask: Const[List[int8_t]], parents: Const[List[int64_t]], length: int64_t, validwhen: bool)#
def awkward_ByteMaskedArray_reduce_next_64(
nextcarry, nextparents, outindex, mask, parents, length, validwhen
):
k = 0
for i in range(length):
if (mask[i] != 0) == validwhen:
nextcarry[k] = i
nextparents[k] = parents[i]
outindex[i] = k
k = k + 1
else:
outindex[i] = -1
awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64#
- awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], mask: Const[List[int8_t]], length: int64_t, valid_when: bool)#
def awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64(
nextshifts, mask, length, valid_when
):
nullsum = 0
k = 0
for i in range(length):
if (mask[i] != 0) == (valid_when != 0):
nextshifts[k] = nullsum
k = k + 1
else:
nullsum = nullsum + 1
awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64#
- awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], mask: Const[List[int8_t]], length: int64_t, valid_when: bool, shifts: Const[List[int64_t]])#
def awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64(
nextshifts, mask, length, valid_when, shifts
):
nullsum = 0
k = 0
for i in range(length):
if (mask[i] != 0) == (valid_when != 0):
nextshifts[k] = shifts[i] + nullsum
k = k + 1
else:
nullsum = nullsum + 1
awkward_ByteMaskedArray_toIndexedOptionArray#
- awkward_ByteMaskedArray_toIndexedOptionArray64(toindex: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)#
def awkward_ByteMaskedArray_toIndexedOptionArray(toindex, mask, length, validwhen):
for i in range(length):
toindex[i] = i if (mask[i] != 0) == validwhen else -1
awkward_Content_getitem_next_missing_jagged_getmaskstartstop#
- awkward_Content_getitem_next_missing_jagged_getmaskstartstop(index_in: List[int64_t], offsets_in: List[int64_t], mask_out: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)#
def awkward_Content_getitem_next_missing_jagged_getmaskstartstop(
index_in, offsets_in, mask_out, starts_out, stops_out, length
):
k = 0
for i in range(length):
starts_out[i] = offsets_in[k]
if index_in[i] < 0:
mask_out[i] = -1
stops_out[i] = offsets_in[k]
else:
mask_out[i] = i
k = k + 1
stops_out[i] = offsets_in[k]
awkward_IndexedArray_fill#
- awkward_IndexedArray_fill_to64_from32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int32_t]], length: int64_t, base: int64_t)#
- awkward_IndexedArray_fill_to64_from64(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int64_t]], length: int64_t, base: int64_t)#
- awkward_IndexedArray_fill_to64_fromU32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[uint32_t]], length: int64_t, base: int64_t)#
def awkward_IndexedArray_fill(toindex, toindexoffset, fromindex, length, base):
for i in range(length):
fromval = fromindex[i]
toindex[toindexoffset + i] = -1 if fromval < 0 else fromval + base
awkward_IndexedArray_fill_count#
- awkward_IndexedArray_fill_to64_count(toindex: List[int64_t], toindexoffset: int64_t, length: int64_t, base: int64_t)#
def awkward_IndexedArray_fill_count(toindex, toindexoffset, length, base):
for i in range(length):
toindex[toindexoffset + i] = i + base
awkward_IndexedArray_flatten_nextcarry#
- awkward_IndexedArray32_flatten_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)#
- awkward_IndexedArray64_flatten_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)#
- awkward_IndexedArrayU32_flatten_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)#
def awkward_IndexedArray_flatten_nextcarry(tocarry, fromindex, lenindex, lencontent):
k = 0
for i in range(lenindex):
j = fromindex[i]
if j >= lencontent:
raise ValueError("index out of range")
else:
if j >= 0:
tocarry[k] = j
k = k + 1
awkward_IndexedArray_flatten_none2empty#
- awkward_IndexedArray32_flatten_none2empty_64(outoffsets: List[int64_t], outindex: Const[List[int32_t]], outindexlength: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t)#
- awkward_IndexedArray64_flatten_none2empty_64(outoffsets: List[int64_t], outindex: Const[List[int64_t]], outindexlength: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t)#
- awkward_IndexedArrayU32_flatten_none2empty_64(outoffsets: List[int64_t], outindex: Const[List[uint32_t]], outindexlength: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t)#
def awkward_IndexedArray_flatten_none2empty(
outoffsets, outindex, outindexlength, offsets, offsetslength
):
outoffsets[0] = offsets[0]
k = 1
for i in range(outindexlength):
idx = outindex[i]
if idx < 0:
outoffsets[k] = outoffsets[k - 1]
k = k + 1
else:
if (idx + 1) >= offsetslength:
raise ValueError("flattening offset out of range")
else:
count = offsets[idx + 1] - offsets[idx]
outoffsets[k] = outoffsets[k - 1] + count
k = k + 1
awkward_IndexedArray_getitem_nextcarry#
- awkward_IndexedArray32_getitem_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)#
- awkward_IndexedArray64_getitem_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)#
- awkward_IndexedArrayU32_getitem_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)#
def awkward_IndexedArray_getitem_nextcarry(tocarry, fromindex, lenindex, lencontent):
k = 0
for i in range(lenindex):
j = fromindex[i]
if (j < 0) or (j >= lencontent):
raise ValueError("index out of range")
else:
tocarry[k] = j
k = k + 1
awkward_IndexedArray_getitem_nextcarry_outindex#
- awkward_IndexedArray32_getitem_nextcarry_outindex_64(tocarry: List[int64_t], toindex: List[int32_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)#
- awkward_IndexedArray64_getitem_nextcarry_outindex_64(tocarry: List[int64_t], toindex: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)#
- awkward_IndexedArrayU32_getitem_nextcarry_outindex_64(tocarry: List[int64_t], toindex: List[uint32_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)#
def awkward_IndexedArray_getitem_nextcarry_outindex(
tocarry, toindex, fromindex, lenindex, lencontent
):
k = 0
for i in range(lenindex):
j = fromindex[i]
if j >= lencontent:
raise ValueError("index out of range")
else:
if j < 0:
toindex[i] = -1
else:
tocarry[k] = j
toindex[i] = k
k = k + 1
awkward_IndexedArray_local_preparenext_64#
- awkward_IndexedArray_local_preparenext_64(tocarry: List[int64_t], starts: Const[List[int64_t]], parents: Const[List[int64_t]], parentslength: Const[int64_t], nextparents: Const[List[int64_t]], nextlen: Const[int64_t])#
def awkward_IndexedArray_local_preparenext_64(
tocarry, starts, parents, parentslength, nextparents, nextlen
):
j = 0
for i in range(parentslength):
parent = parents[i];
if j < nextlen and parent == nextparents[j]:
tocarry[i] = j;
j += 1;
else:
tocarry[i] = -1;
awkward_IndexedArray_numnull#
- awkward_IndexedArray32_numnull(numnull: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t)#
- awkward_IndexedArray64_numnull(numnull: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t)#
- awkward_IndexedArrayU32_numnull(numnull: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t)#
def awkward_IndexedArray_numnull(numnull, fromindex, lenindex):
numnull[0] = 0
for i in range(lenindex):
if fromindex[i] < 0:
numnull[0] = numnull[0] + 1
awkward_IndexedArray_numnull_parents#
- awkward_IndexedArray32_numnull_parents(numnull: List[int64_t], tolength: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t)#
- awkward_IndexedArray64_numnull_parents(numnull: List[int64_t], tolength: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t)#
- awkward_IndexedArrayU32_numnull_parents(numnull: List[int64_t], tolength: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t)#
def awkward_IndexedArray_numnull_parents(numnull, tolength, fromindex, lenindex):
tolength[0] = 0
for i in range(lenindex):
if fromindex[i] < 0:
numnull[i] = 1
tolength[0] = tolength[0] + 1
else:
numnull[i] = 0
awkward_IndexedArray_numnull_unique_64#
- awkward_IndexedArray_numnull_unique_64(toindex: List[int64_t], lenindex: int64_t)#
def awkward_IndexedArray_numnull_unique_64(toindex, lenindex):
for i in range(lenindex):
toindex[i] = i
toindex[-1] = -1
awkward_IndexedArray_index_of_nulls#
- awkward_IndexedArray32_index_of_nulls(toindex: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])#
- awkward_IndexedArray64_index_of_nulls(toindex: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])#
- awkward_IndexedArrayU32_index_of_nulls(toindex: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])#
def awkward_IndexedArray_index_of_nulls(toindex, fromindex, lenindex, parents, starts):
j = 0
for i in range(lenindex):
if fromindex[i] < 0:
parent = parents[i]
start = starts[parent]
toindex[j] = i - start
j = j + 1
awkward_IndexedArray_overlay_mask#
- awkward_IndexedArray32_overlay_mask8_to64(toindex: List[int64_t], mask: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t)#
- awkward_IndexedArray64_overlay_mask8_to64(toindex: List[int64_t], mask: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t)#
- awkward_IndexedArrayU32_overlay_mask8_to64(toindex: List[int64_t], mask: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t)#
def awkward_IndexedArray_overlay_mask(toindex, mask, fromindex, length):
for i in range(length):
m = mask[i]
toindex[i] = -1 if m else fromindex[i]
awkward_IndexedArray_reduce_next_64#
- awkward_IndexedArray32_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], index: Const[List[int32_t]], parents: List[int64_t], length: int64_t)#
- awkward_IndexedArray64_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], index: Const[List[int64_t]], parents: List[int64_t], length: int64_t)#
- awkward_IndexedArrayU32_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], index: Const[List[uint32_t]], parents: List[int64_t], length: int64_t)#
def awkward_IndexedArray_reduce_next_64(
nextcarry, nextparents, outindex, index, parents, length
):
k = 0
for i in range(length):
if index[i] >= 0:
nextcarry[k] = index[i]
nextparents[k] = parents[i]
outindex[i] = k
k = k + 1
else:
outindex[i] = -1
awkward_IndexedArray_reduce_next_fix_offsets_64#
- awkward_IndexedArray_reduce_next_fix_offsets_64(outoffsets: List[int64_t], starts: Const[List[int64_t]], startslength: int64_t, outindexlength: int64_t)#
def awkward_IndexedArray_reduce_next_fix_offsets_64(
outoffsets, starts, startslength, outindexlength
):
for i in range(startslength):
outoffsets[i] = starts[i]
outoffsets[startslength] = outindexlength
awkward_IndexedArray_unique_next_index_and_offsets_64#
- awkward_IndexedArray_unique_next_index_and_offsets_64(toindex: List[int64_t], tooffsets: List[int64_t], fromoffsets: Const[List[int64_t]], fromnulls: Const[List[int64_t]], startslength: int64_t)#
def awkward_IndexedArray_unique_next_index_and_offsets_64(
toindex, tooffsets, fromoffsets, fromnulls, startslength
):
k = 0
ll = 0
shift = 0
toindex[0] = ll
tooffsets[0] = fromoffsets[0]
for i in range(startslength):
for _j in range(fromoffsets[i], fromoffsets[i + 1]):
toindex[k] = ll
k += 1
ll += 1
if fromnulls[k] == 1:
toindex[k] = -1
k += 1
shift += 1
tooffsets[i + 1] = fromoffsets[i + 1] + shift
awkward_IndexedArray_reduce_next_nonlocal_nextshifts_64#
- awkward_IndexedArray32_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], index: Const[List[int32_t]], length: int64_t)#
- awkward_IndexedArray64_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], index: Const[List[int64_t]], length: int64_t)#
- awkward_IndexedArrayU32_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], index: Const[List[uint32_t]], length: int64_t)#
def awkward_IndexedArray_reduce_next_nonlocal_nextshifts_64(nextshifts, index, length):
nullsum = 0
k = 0
for i in range(length):
if index[i] >= 0:
nextshifts[k] = nullsum
k = k + 1
else:
nullsum = nullsum + 1
awkward_IndexedArray_reduce_next_nonlocal_nextshifts_fromshifts_64#
- awkward_IndexedArray32_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], index: Const[List[int32_t]], length: int64_t, shifts: Const[List[int64_t]])#
- awkward_IndexedArray64_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], index: Const[List[int64_t]], length: int64_t, shifts: Const[List[int64_t]])#
- awkward_IndexedArrayU32_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], index: Const[List[uint32_t]], length: int64_t, shifts: Const[List[int64_t]])#
def awkward_IndexedArray_reduce_next_nonlocal_nextshifts_fromshifts_64(
nextshifts, index, length, shifts
):
nullsum = 0
k = 0
for i in range(length):
if index[i] >= 0:
nextshifts[k] = shifts[i] + nullsum
k = k + 1
else:
nullsum = nullsum + 1
awkward_IndexedArray_simplify#
- awkward_IndexedArray32_simplify32_to64(toindex: List[int64_t], outerindex: Const[List[int32_t]], outerlength: int64_t, innerindex: Const[List[int32_t]], innerlength: int64_t)#
- awkward_IndexedArray32_simplify64_to64(toindex: List[int64_t], outerindex: Const[List[int32_t]], outerlength: int64_t, innerindex: Const[List[int64_t]], innerlength: int64_t)#
- awkward_IndexedArray32_simplifyU32_to64(toindex: List[int64_t], outerindex: Const[List[int32_t]], outerlength: int64_t, innerindex: Const[List[uint32_t]], innerlength: int64_t)#
- awkward_IndexedArray64_simplify32_to64(toindex: List[int64_t], outerindex: Const[List[int64_t]], outerlength: int64_t, innerindex: Const[List[int32_t]], innerlength: int64_t)#
- awkward_IndexedArray64_simplify64_to64(toindex: List[int64_t], outerindex: Const[List[int64_t]], outerlength: int64_t, innerindex: Const[List[int64_t]], innerlength: int64_t)#
- awkward_IndexedArray64_simplifyU32_to64(toindex: List[int64_t], outerindex: Const[List[int64_t]], outerlength: int64_t, innerindex: Const[List[uint32_t]], innerlength: int64_t)#
- awkward_IndexedArrayU32_simplify32_to64(toindex: List[int64_t], outerindex: Const[List[uint32_t]], outerlength: int64_t, innerindex: Const[List[int32_t]], innerlength: int64_t)#
- awkward_IndexedArrayU32_simplify64_to64(toindex: List[int64_t], outerindex: Const[List[uint32_t]], outerlength: int64_t, innerindex: Const[List[int64_t]], innerlength: int64_t)#
- awkward_IndexedArrayU32_simplifyU32_to64(toindex: List[int64_t], outerindex: Const[List[uint32_t]], outerlength: int64_t, innerindex: Const[List[uint32_t]], innerlength: int64_t)#
def awkward_IndexedArray_simplify(
toindex, outerindex, outerlength, innerindex, innerlength
):
for i in range(outerlength):
j = outerindex[i]
if j < 0:
toindex[i] = -1
else:
if j >= innerlength:
raise ValueError("index out of range")
else:
toindex[i] = innerindex[j]
awkward_IndexedArray_validity#
- awkward_IndexedArray32_validity(index: Const[List[int32_t]], length: int64_t, lencontent: int64_t, isoption: bool)#
- awkward_IndexedArray64_validity(index: Const[List[int64_t]], length: int64_t, lencontent: int64_t, isoption: bool)#
- awkward_IndexedArrayU32_validity(index: Const[List[uint32_t]], length: int64_t, lencontent: int64_t, isoption: bool)#
def awkward_IndexedArray_validity(index, length, lencontent, isoption):
for i in range(length):
idx = index[i]
if not (isoption):
if idx < 0:
raise ValueError("index[i] < 0")
if idx >= lencontent:
raise ValueError("index[i] >= len(content)")
awkward_IndexedArray_ranges_next_64#
- awkward_IndexedArray32_ranges_next_64(index: Const[List[int32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tostarts: List[int64_t], tostops: List[int64_t], tolength: List[int64_t])#
- awkward_IndexedArray64_ranges_next_64(index: Const[List[int64_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tostarts: List[int64_t], tostops: List[int64_t], tolength: List[int64_t])#
- awkward_IndexedArrayU32_ranges_next_64(index: Const[List[uint32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tostarts: List[int64_t], tostops: List[int64_t], tolength: List[int64_t])#
def awkward_IndexedArray_ranges_next_64(
index, fromstarts, fromstops, length, tostarts, tostops, tolength
):
k = 0
for i in range(length):
stride = fromstops[i] - fromstarts[i]
tostarts[i] = k
for j in range(stride):
if index[fromstarts[i] + j] >= 0:
k = k + 1
tostops[i] = k
tolength[0] = k
awkward_IndexedArray_ranges_carry_next_64#
- awkward_IndexedArray32_ranges_carry_next_64(index: Const[List[int32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tocarry: List[int64_t])#
- awkward_IndexedArray64_ranges_carry_next_64(index: Const[List[int64_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tocarry: List[int64_t])#
- awkward_IndexedArrayU32_ranges_carry_next_64(index: Const[List[uint32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tocarry: List[int64_t])#
def awkward_IndexedArray_ranges_carry_next_64(
index, fromstarts, fromstops, length, tocarry
):
k = 0
for i in range(length):
stride = fromstops[i] - fromstarts[i]
for j in range(stride):
if index[fromstarts[i] + j] >= 0:
tocarry[k] = index[fromstarts[i] + j]
k = k + 1
awkward_IndexedOptionArray_rpad_and_clip_mask_axis1#
- awkward_IndexedOptionArray_rpad_and_clip_mask_axis1_64(toindex: List[int64_t], frommask: Const[List[int8_t]], length: int64_t)#
def awkward_IndexedOptionArray_rpad_and_clip_mask_axis1(toindex, frommask, length):
count = 0
for i in range(length):
if frommask[i]:
toindex[i] = -1
else:
toindex[i] = count
count = count + 1
awkward_ListArray_broadcast_tooffsets#
- awkward_ListArray32_broadcast_tooffsets_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lencontent: int64_t)#
- awkward_ListArray64_broadcast_tooffsets_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lencontent: int64_t)#
- awkward_ListArrayU32_broadcast_tooffsets_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lencontent: int64_t)#
def awkward_ListArray_broadcast_tooffsets(
tocarry, fromoffsets, offsetslength, fromstarts, fromstops, lencontent
):
k = 0
for i in range(offsetslength - 1):
start = int(fromstarts[i])
stop = int(fromstops[i])
if (start != stop) and (stop > lencontent):
raise ValueError("stops[i] > len(content)")
count = int(fromoffsets[i + 1] - fromoffsets[i])
if count < 0:
raise ValueError("broadcast's offsets must be monotonically increasing")
if (stop - start) != count:
raise ValueError("cannot broadcast nested list")
for j in range(start, stop):
tocarry[k] = j
k = k + 1
awkward_ListArray_combinations#
- awkward_ListArray32_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int32_t]], stops: Const[List[int32_t]], length: int64_t)#
- awkward_ListArray64_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int64_t]], stops: Const[List[int64_t]], length: int64_t)#
- awkward_ListArrayU32_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[uint32_t]], stops: Const[List[uint32_t]], length: int64_t)#
def awkward_ListArray_combinations(
tocarry, toindex, fromindex, n, replacement, starts, stops, length
):
for j in range(n):
toindex[j] = 0
for i in range(length):
start = int(starts[i])
stop = int(stops[i])
fromindex[0] = start
awkward_ListArray_combinations_step(
tocarry, toindex, fromindex, 0, stop, n, replacement
)
awkward_ListArray_combinations_length#
- awkward_ListArray32_combinations_length_64(totallen: List[int64_t], tooffsets: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int32_t]], stops: Const[List[int32_t]], length: int64_t)#
- awkward_ListArray64_combinations_length_64(totallen: List[int64_t], tooffsets: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int64_t]], stops: Const[List[int64_t]], length: int64_t)#
- awkward_ListArrayU32_combinations_length_64(totallen: List[int64_t], tooffsets: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[uint32_t]], stops: Const[List[uint32_t]], length: int64_t)#
def awkward_ListArray_combinations_length(
totallen, tooffsets, n, replacement, starts, stops, length
):
totallen[0] = 0
tooffsets[0] = 0
for i in range(length):
size = int(stops[i] - starts[i])
if replacement:
size += n - 1
thisn = n
if thisn > size:
combinationslen = 0
else:
if thisn == size:
combinationslen = 1
else:
if (thisn * 2) > size:
thisn = size - thisn
combinationslen = size
j = 2
while j <= thisn:
combinationslen *= (size - j) + 1
combinationslen /= j
j = j + 1
totallen[0] = totallen[0] + combinationslen
tooffsets[i + 1] = tooffsets[i] + combinationslen
awkward_ListArray_compact_offsets#
- awkward_ListArray32_compact_offsets_64(tooffsets: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], length: int64_t)#
- awkward_ListArray64_compact_offsets_64(tooffsets: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t)#
- awkward_ListArrayU32_compact_offsets_64(tooffsets: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], length: int64_t)#
def awkward_ListArray_compact_offsets(tooffsets, fromstarts, fromstops, length):
tooffsets[0] = 0
for i in range(length):
start = fromstarts[i]
stop = fromstops[i]
if stop < start:
raise ValueError("stops[i] < starts[i]")
tooffsets[i + 1] = tooffsets[i] + (stop - start)
awkward_ListArray_fill#
- awkward_ListArray_fill_to64_from32(tostarts: List[int64_t], tostartsoffset: int64_t, tostops: List[int64_t], tostopsoffset: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], length: int64_t, base: int64_t)#
- awkward_ListArray_fill_to64_from64(tostarts: List[int64_t], tostartsoffset: int64_t, tostops: List[int64_t], tostopsoffset: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, base: int64_t)#
- awkward_ListArray_fill_to64_fromU32(tostarts: List[int64_t], tostartsoffset: int64_t, tostops: List[int64_t], tostopsoffset: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], length: int64_t, base: int64_t)#
def awkward_ListArray_fill(
tostarts,
tostartsoffset,
tostops,
tostopsoffset,
fromstarts,
fromstops,
length,
base,
):
for i in range(length):
tostarts[tostartsoffset + i] = fromstarts[i] + base
tostops[tostopsoffset + i] = fromstops[i] + base
awkward_ListArray_getitem_jagged_apply#
- awkward_ListArray32_getitem_jagged_apply_64(tooffsets: List[int64_t], tocarry: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, sliceindex: Const[List[int64_t]], sliceinnerlen: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], contentlen: int64_t)#
- awkward_ListArray64_getitem_jagged_apply_64(tooffsets: List[int64_t], tocarry: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, sliceindex: Const[List[int64_t]], sliceinnerlen: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], contentlen: int64_t)#
- awkward_ListArrayU32_getitem_jagged_apply_64(tooffsets: List[int64_t], tocarry: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, sliceindex: Const[List[int64_t]], sliceinnerlen: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], contentlen: int64_t)#
def awkward_ListArray_getitem_jagged_apply(
tooffsets,
tocarry,
slicestarts,
slicestops,
sliceouterlen,
sliceindex,
sliceinnerlen,
fromstarts,
fromstops,
contentlen,
):
k = 0
for i in range(sliceouterlen):
slicestart = slicestarts[i]
slicestop = slicestops[i]
tooffsets[i] = k
if slicestart != slicestop:
if slicestop < slicestart:
raise ValueError("jagged slice's stops[i] < starts[i]")
if slicestop > sliceinnerlen:
raise ValueError("jagged slice's offsets extend beyond its content")
start = int(fromstarts[i])
stop = int(fromstops[i])
if stop < start:
raise ValueError("stops[i] < starts[i]")
if (start != stop) and (stop > contentlen):
raise ValueError("stops[i] > len(content)")
count = stop - start
for j in range(slicestart, slicestop):
index = int(sliceindex[j])
if index < 0:
index += count
if not ((0 <= index) and (index < count)):
raise ValueError("index out of range")
tocarry[k] = start + index
k = k + 1
tooffsets[sliceouterlen] = k
awkward_ListArray_getitem_jagged_carrylen#
- awkward_ListArray_getitem_jagged_carrylen_64(carrylen: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t)#
def awkward_ListArray_getitem_jagged_carrylen(
carrylen, slicestarts, slicestops, sliceouterlen
):
carrylen[0] = 0
for i in range(sliceouterlen):
carrylen[0] = carrylen[0] + int(slicestops[i] - slicestarts[i])
awkward_ListArray_getitem_jagged_descend#
- awkward_ListArray32_getitem_jagged_descend_64(tooffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]])#
- awkward_ListArray64_getitem_jagged_descend_64(tooffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]])#
- awkward_ListArrayU32_getitem_jagged_descend_64(tooffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]])#
def awkward_ListArray_getitem_jagged_descend(
tooffsets, slicestarts, slicestops, sliceouterlen, fromstarts, fromstops
):
if sliceouterlen == 0:
tooffsets[0] = 0
else:
tooffsets[0] = slicestarts[0]
for i in range(sliceouterlen):
slicecount = int(slicestops[i] - slicestarts[i])
count = int(fromstops[i] - fromstarts[i])
if slicecount != count:
raise ValueError(
"jagged slice inner length differs from array inner length"
)
tooffsets[i + 1] = tooffsets[i] + count
awkward_ListArray_getitem_jagged_expand#
- awkward_ListArray32_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], tocarry: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], jaggedsize: int64_t, length: int64_t)#
- awkward_ListArray64_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], tocarry: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], jaggedsize: int64_t, length: int64_t)#
- awkward_ListArrayU32_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], tocarry: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], jaggedsize: int64_t, length: int64_t)#
def awkward_ListArray_getitem_jagged_expand(
multistarts,
multistops,
singleoffsets,
tocarry,
fromstarts,
fromstops,
jaggedsize,
length,
):
for i in range(length):
start = fromstarts[i]
stop = fromstops[i]
if stop < start:
raise ValueError("stops[i] < starts[i]")
if (stop - start) != jaggedsize:
raise ValueError("cannot fit jagged slice into nested list")
for j in range(jaggedsize):
multistarts[(i * jaggedsize) + j] = singleoffsets[j]
multistops[(i * jaggedsize) + j] = singleoffsets[j + 1]
tocarry[(i * jaggedsize) + j] = start + j
awkward_ListArray_getitem_jagged_numvalid#
- awkward_ListArray_getitem_jagged_numvalid_64(numvalid: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], length: int64_t, missing: Const[List[int64_t]], missinglength: int64_t)#
def awkward_ListArray_getitem_jagged_numvalid(
numvalid, slicestarts, slicestops, length, missing, missinglength
):
numvalid[0] = 0
for i in range(length):
slicestart = slicestarts[i]
slicestop = slicestops[i]
if slicestart != slicestop:
if slicestop < slicestart:
raise ValueError("jagged slice's stops[i] < starts[i]")
if slicestop > missinglength:
raise ValueError("jagged slice's offsets extend beyond its content")
for j in range(slicestart, slicestop):
if missing[j] >= 0:
numvalid[0] = numvalid[0] + 1
awkward_ListArray_getitem_jagged_shrink#
- awkward_ListArray_getitem_jagged_shrink_64(tocarry: List[int64_t], tosmalloffsets: List[int64_t], tolargeoffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], length: int64_t, missing: Const[List[int64_t]])#
def awkward_ListArray_getitem_jagged_shrink(
tocarry, tosmalloffsets, tolargeoffsets, slicestarts, slicestops, length, missing
):
k = 0
if length == 0:
tosmalloffsets[0] = 0
tolargeoffsets[0] = 0
else:
tosmalloffsets[0] = slicestarts[0]
tolargeoffsets[0] = slicestarts[0]
for i in range(length):
slicestart = slicestarts[i]
slicestop = slicestops[i]
if slicestart != slicestop:
smallcount = 0
for j in range(slicestart, slicestop):
if missing[j] >= 0:
tocarry[k] = j
k = k + 1
smallcount = smallcount + 1
tosmalloffsets[i + 1] = tosmalloffsets[i] + smallcount
else:
tosmalloffsets[i + 1] = tosmalloffsets[i]
tolargeoffsets[i + 1] = tolargeoffsets[i] + (slicestop - slicestart)
awkward_ListArray_getitem_next_array#
- awkward_ListArray32_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], fromarray: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)#
- awkward_ListArray64_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], fromarray: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)#
- awkward_ListArrayU32_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], fromarray: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)#
def awkward_ListArray_getitem_next_array(
tocarry,
toadvanced,
fromstarts,
fromstops,
fromarray,
lenstarts,
lenarray,
lencontent,
):
for i in range(lenstarts):
if fromstops[i] < fromstarts[i]:
raise ValueError("stops[i] < starts[i]")
if (fromstarts[i] != fromstops[i]) and (fromstops[i] > lencontent):
raise ValueError("stops[i] > len(content)")
length = fromstops[i] - fromstarts[i]
for j in range(lenarray):
regular_at = fromarray[j]
if regular_at < 0:
regular_at += length
if not ((0 <= regular_at) and (regular_at < length)):
raise ValueError("index out of range")
tocarry[(i * lenarray) + j] = fromstarts[i] + regular_at
toadvanced[(i * lenarray) + j] = j
awkward_ListArray_getitem_next_array_advanced#
- awkward_ListArray32_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], fromarray: Const[List[int64_t]], fromadvanced: Const[List[int64_t]], lenstarts: int64_t, lencontent: int64_t)#
- awkward_ListArray64_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], fromarray: Const[List[int64_t]], fromadvanced: Const[List[int64_t]], lenstarts: int64_t, lencontent: int64_t)#
- awkward_ListArrayU32_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], fromarray: Const[List[int64_t]], fromadvanced: Const[List[int64_t]], lenstarts: int64_t, lencontent: int64_t)#
def awkward_ListArray_getitem_next_array_advanced(
tocarry,
toadvanced,
fromstarts,
fromstops,
fromarray,
fromadvanced,
lenstarts,
lencontent,
):
for i in range(lenstarts):
if fromstops[i] < fromstarts[i]:
raise ValueError("stops[i] < starts[i]")
if (fromstarts[i] != fromstops[i]) and (fromstops[i] > lencontent):
raise ValueError("stops[i] > len(content)")
length = fromstops[i] - fromstarts[i]
regular_at = fromarray[fromadvanced[i]]
if regular_at < 0:
regular_at += length
if not ((0 <= regular_at) and (regular_at < length)):
raise ValueError("index out of range")
tocarry[i] = fromstarts[i] + regular_at
toadvanced[i] = i
awkward_ListArray_getitem_next_at#
- awkward_ListArray32_getitem_next_at_64(tocarry: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t, at: int64_t)#
- awkward_ListArray64_getitem_next_at_64(tocarry: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t, at: int64_t)#
- awkward_ListArrayU32_getitem_next_at_64(tocarry: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t, at: int64_t)#
def awkward_ListArray_getitem_next_at(tocarry, fromstarts, fromstops, lenstarts, at):
for i in range(lenstarts):
length = fromstops[i] - fromstarts[i]
regular_at = at
if regular_at < 0:
regular_at += length
if not ((0 <= regular_at) and (regular_at < length)):
raise ValueError("index out of range")
tocarry[i] = fromstarts[i] + regular_at
awkward_ListArray_getitem_next_range#
- awkward_ListArray32_getitem_next_range_64(tooffsets: List[int32_t], tocarry: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)#
- awkward_ListArray64_getitem_next_range_64(tooffsets: List[int64_t], tocarry: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)#
- awkward_ListArrayU32_getitem_next_range_64(tooffsets: List[uint32_t], tocarry: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)#
def awkward_ListArray_getitem_next_range(
tooffsets, tocarry, fromstarts, fromstops, lenstarts, start, stop, step
):
k = 0
tooffsets[0] = 0
for i in range(lenstarts):
length = fromstops[i] - fromstarts[i]
regular_start = start
regular_stop = stop
regular_start, regular_stop = awkward_regularize_rangeslice(
regular_start,
regular_stop,
step > 0,
start != kSliceNone,
stop != kSliceNone,
length,
)
j = regular_start
if step > 0:
while j < regular_stop:
tocarry[k] = fromstarts[i] + j
k = k + 1
j += step
else:
while j > regular_stop:
tocarry[k] = fromstarts[i] + j
k = k + 1
j += step
tooffsets[i + 1] = k
awkward_ListArray_getitem_next_range_carrylength#
- awkward_ListArray32_getitem_next_range_carrylength(carrylength: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)#
- awkward_ListArray64_getitem_next_range_carrylength(carrylength: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)#
- awkward_ListArrayU32_getitem_next_range_carrylength(carrylength: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)#
def awkward_ListArray_getitem_next_range_carrylength(
carrylength, fromstarts, fromstops, lenstarts, start, stop, step
):
carrylength[0] = 0
for i in range(lenstarts):
length = fromstops[i] - fromstarts[i]
regular_start = start
regular_stop = stop
regular_start, regular_stop = awkward_regularize_rangeslice(
regular_start,
regular_stop,
step > 0,
start != kSliceNone,
stop != kSliceNone,
length,
)
if step > 0:
j = regular_start
while j < regular_stop:
carrylength[0] = carrylength[0] + 1
j += step
else:
j = regular_start
while j > regular_stop:
carrylength[0] = carrylength[0] + 1
j += step
awkward_ListArray_getitem_next_range_counts#
- awkward_ListArray32_getitem_next_range_counts_64(total: List[int64_t], fromoffsets: Const[List[int32_t]], lenstarts: int64_t)#
- awkward_ListArray64_getitem_next_range_counts_64(total: List[int64_t], fromoffsets: Const[List[int64_t]], lenstarts: int64_t)#
- awkward_ListArrayU32_getitem_next_range_counts_64(total: List[int64_t], fromoffsets: Const[List[uint32_t]], lenstarts: int64_t)#
def awkward_ListArray_getitem_next_range_counts(total, fromoffsets, lenstarts):
total[0] = 0
for i in range(lenstarts):
total[0] = (total[0] + fromoffsets[i + 1]) - fromoffsets[i]
awkward_ListArray_getitem_next_range_spreadadvanced#
- awkward_ListArray32_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromoffsets: Const[List[int32_t]], lenstarts: int64_t)#
- awkward_ListArray64_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromoffsets: Const[List[int64_t]], lenstarts: int64_t)#
- awkward_ListArrayU32_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromoffsets: Const[List[uint32_t]], lenstarts: int64_t)#
def awkward_ListArray_getitem_next_range_spreadadvanced(
toadvanced, fromadvanced, fromoffsets, lenstarts
):
for i in range(lenstarts):
count = fromoffsets[i + 1] - fromoffsets[i]
for j in range(count):
toadvanced[fromoffsets[i] + j] = fromadvanced[i]
awkward_ListArray_localindex#
- awkward_ListArray32_localindex_64(toindex: List[int64_t], offsets: Const[List[int32_t]], length: int64_t)#
- awkward_ListArray64_localindex_64(toindex: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)#
- awkward_ListArrayU32_localindex_64(toindex: List[int64_t], offsets: Const[List[uint32_t]], length: int64_t)#
def awkward_ListArray_localindex(toindex, offsets, length):
for i in range(length):
start = int(offsets[i])
stop = int(offsets[i + 1])
for j in range(start, stop):
toindex[j] = j - start
awkward_ListArray_min_range#
- awkward_ListArray32_min_range(tomin: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t)#
- awkward_ListArray64_min_range(tomin: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t)#
- awkward_ListArrayU32_min_range(tomin: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t)#
def awkward_ListArray_min_range(tomin, fromstarts, fromstops, lenstarts):
if lenstarts > 0:
shorter = fromstops[0] - fromstarts[0]
for i in range(1, lenstarts):
rangeval = fromstops[i] - fromstarts[i]
shorter = shorter if shorter < rangeval else rangeval
tomin[0] = shorter
awkward_ListArray_rpad_and_clip_length_axis1#
- awkward_ListArray32_rpad_and_clip_length_axis1(tomin: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], target: int64_t, lenstarts: int64_t)#
- awkward_ListArray64_rpad_and_clip_length_axis1(tomin: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], target: int64_t, lenstarts: int64_t)#
- awkward_ListArrayU32_rpad_and_clip_length_axis1(tomin: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], target: int64_t, lenstarts: int64_t)#
def awkward_ListArray_rpad_and_clip_length_axis1(
tomin, fromstarts, fromstops, target, lenstarts
):
length = 0
for i in range(lenstarts):
rangeval = fromstops[i] - fromstarts[i]
length += target if target > rangeval else rangeval
tomin[0] = length
awkward_ListArray_rpad_axis1#
- awkward_ListArray32_rpad_axis1_64(toindex: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], tostarts: List[int32_t], tostops: List[int32_t], target: int64_t, length: int64_t)#
- awkward_ListArray64_rpad_axis1_64(toindex: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], tostarts: List[int64_t], tostops: List[int64_t], target: int64_t, length: int64_t)#
- awkward_ListArrayU32_rpad_axis1_64(toindex: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], tostarts: List[uint32_t], tostops: List[uint32_t], target: int64_t, length: int64_t)#
def awkward_ListArray_rpad_axis1(
toindex, fromstarts, fromstops, tostarts, tostops, target, length
):
offset = 0
for i in range(length):
tostarts[i] = offset
rangeval = fromstops[i] - fromstarts[i]
for j in range(rangeval):
toindex[offset + j] = fromstarts[i] + j
for j in range(rangeval, target):
toindex[offset + j] = -1
offset = tostarts[i] + target if target > rangeval else tostarts[i] + rangeval
tostops[i] = offset
awkward_ListArray_validity#
- awkward_ListArray32_validity(starts: Const[List[int32_t]], stops: Const[List[int32_t]], length: int64_t, lencontent: int64_t)#
- awkward_ListArray64_validity(starts: Const[List[int64_t]], stops: Const[List[int64_t]], length: int64_t, lencontent: int64_t)#
- awkward_ListArrayU32_validity(starts: Const[List[uint32_t]], stops: Const[List[uint32_t]], length: int64_t, lencontent: int64_t)#
def awkward_ListArray_validity(starts, stops, length, lencontent):
for i in range(length):
start = starts[i]
stop = stops[i]
if start != stop:
if start > stop:
raise ValueError("start[i] > stop[i]")
if start < 0:
raise ValueError("start[i] < 0")
if stop > lencontent:
raise ValueError("stop[i] > len(content)")
awkward_ListOffsetArray_drop_none_indexes#
- awkward_ListOffsetArray_drop_none_indexes_32(tooffsets: List[int32_t], noneindexes: Const[List[int32_t]], fromoffsets: Const[List[int32_t]], length_offsets: int64_t, length_indexes: int64_t)#
- awkward_ListOffsetArray_drop_none_indexes_64(tooffsets: List[int64_t], noneindexes: Const[List[int64_t]], fromoffsets: Const[List[int64_t]], length_offsets: int64_t, length_indexes: int64_t)#
def awkward_ListOffsetArray_drop_none_indexes(tooffsets, noneindexes, fromoffsets, length_offsets, length_indexes):
nr_of_nones, offset1, offset2 = 0, 0, 0
for i in range(length_offsets):
offset2 = fromoffsets[i]
for j in range(offset1, offset2):
if (noneindexes[j] < 0):
nr_of_nones+=1
tooffsets[i] = fromoffsets[i] - nr_of_nones
offset1 = offset2
awkward_ListOffsetArray_flatten_offsets#
- awkward_ListOffsetArray32_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[int32_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]])#
- awkward_ListOffsetArray64_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[int64_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]])#
- awkward_ListOffsetArrayU32_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[uint32_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]])#
def awkward_ListOffsetArray_flatten_offsets(
tooffsets, outeroffsets, outeroffsetslen, inneroffsets
):
for i in range(outeroffsetslen):
tooffsets[i] = inneroffsets[outeroffsets[i]]
awkward_ListOffsetArray_local_preparenext_64#
- awkward_ListOffsetArray_local_preparenext_64(tocarry: List[int64_t], fromindex: Const[List[int64_t]], length: int64_t)#
def awkward_ListOffsetArray_local_preparenext_64(tocarry, fromindex, length):
array = numpy.argsort(fromindex)
for i in range(length):
tocarry[i] = array[i]
awkward_ListOffsetArray_reduce_local_nextparents_64#
- awkward_ListOffsetArray32_reduce_local_nextparents_64(nextparents: List[int64_t], offsets: Const[List[int32_t]], length: int64_t)#
- awkward_ListOffsetArray64_reduce_local_nextparents_64(nextparents: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)#
- awkward_ListOffsetArrayU32_reduce_local_nextparents_64(nextparents: List[int64_t], offsets: Const[List[uint32_t]], length: int64_t)#
def awkward_ListOffsetArray_reduce_local_nextparents_64(nextparents, offsets, length):
initialoffset = offsets[0]
for i in range(length):
j = offsets[i] - initialoffset
while j < (offsets[i + 1] - initialoffset):
nextparents[j] = i
j = j + 1
awkward_ListOffsetArray_reduce_local_outoffsets_64#
- awkward_ListOffsetArray_reduce_local_outoffsets_64(outoffsets: List[int64_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_ListOffsetArray_reduce_local_outoffsets_64(
outoffsets, parents, lenparents, outlength
):
k = 0
last = -1
for i in range(lenparents):
while last < parents[i]:
outoffsets[k] = i
k = k + 1
last = last + 1
while k <= outlength:
outoffsets[k] = lenparents
k = k + 1
awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64#
- awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64(maxcount: List[int64_t], offsetscopy: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)#
def awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64(
maxcount, offsetscopy, offsets, length
):
maxcount[0] = 0
offsetscopy[0] = offsets[0]
for i in range(length):
count = offsets[i + 1] - offsets[i]
if maxcount[0] < count:
maxcount[0] = count
offsetscopy[i + 1] = offsets[i + 1]
awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64#
- awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64(nummissing: List[int64_t], missing: List[int64_t], nextshifts: List[int64_t], offsets: Const[List[int64_t]], length: int64_t, starts: Const[List[int64_t]], parents: Const[List[int64_t]], maxcount: int64_t, nextlen: int64_t, nextcarry: Const[List[int64_t]])#
def awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64(
nummissing,
missing,
nextshifts,
offsets,
length,
starts,
parents,
maxcount,
nextlen,
nextcarry,
):
for i in range(length):
start = offsets[i]
stop = offsets[i + 1]
count = stop - start
if starts[parents[i]] == i:
for k in range(maxcount):
nummissing[k] = 0
for k in range(count, maxcount):
nummissing[k] = nummissing[k] + 1
for j in range(count):
missing[start + j] = nummissing[j]
for j in range(nextlen):
nextshifts[j] = missing[nextcarry[j]]
awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64#
- awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64(nextstarts: List[int64_t], nextparents: Const[List[int64_t]], nextlen: int64_t)#
def awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64(
nextstarts, nextparents, nextlen
):
lastnextparent = -1
for i in range(nextlen):
if nextparents[i] != lastnextparent:
nextstarts[nextparents[i]] = i
lastnextparent = nextparents[i]
awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64#
- awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64(outstarts: List[int64_t], outstops: List[int64_t], distincts: Const[List[int64_t]], lendistincts: int64_t, outlength: int64_t)#
def awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64(
outstarts, outstops, distincts, lendistincts, outlength
):
maxcount = lendistincts if (outlength == 0) else int(lendistincts // outlength)
if outlength > 0 and lendistincts > 0:
# The sublist index
k = 0
i_next_sublist = 0
for i in range(lendistincts):
# Are we now in the next sublist?
if i == i_next_sublist:
# Advance counter
i_next_sublist += maxcount
# Add a new sublist
outstarts[k] = i
outstops[k] = i
k += 1
# Expand stop index of previous list
if distincts[i] != -1:
outstops[k - 1] = i + 1
else:
for k in range(outlength):
outstarts[k] = 0
outstops[k] = 0
awkward_ListOffsetArray_reduce_nonlocal_preparenext_64#
- awkward_ListOffsetArray_reduce_nonlocal_preparenext_64(nextcarry: List[int64_t], nextparents: List[int64_t], nextlen: int64_t, maxnextparents: List[int64_t], distincts: List[int64_t], distinctslen: int64_t, offsetscopy: List[int64_t], offsets: Const[List[int64_t]], length: int64_t, parents: Const[List[int64_t]], maxcount: int64_t)#
def awkward_ListOffsetArray_reduce_nonlocal_preparenext_64(
nextcarry,
nextparents,
nextlen,
maxnextparents,
distincts,
distinctslen,
offsetscopy,
offsets,
length,
parents,
maxcount,
):
maxnextparents[0] = 0
for i in range(distinctslen):
distincts[i] = -1
k = 0
while k < nextlen:
j = 0
for i in range(length):
if offsetscopy[i] < offsets[i + 1]:
diff = offsetscopy[i] - offsets[i]
parent = parents[i]
nextcarry[k] = offsetscopy[i]
nextparents[k] = parent*maxcount + diff
if maxnextparents[0] < nextparents[k]:
maxnextparents[0] = nextparents[k]
if nextparents[k] < distinctslen and distincts[nextparents[k]] == -1:
distincts[nextparents[k]] = j
j += 1
k += 1
offsetscopy[i] += 1
awkward_ListOffsetArray_rpad_and_clip_axis1#
- awkward_ListOffsetArray32_rpad_and_clip_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int32_t]], length: int64_t, target: int64_t)#
- awkward_ListOffsetArray64_rpad_and_clip_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int64_t]], length: int64_t, target: int64_t)#
- awkward_ListOffsetArrayU32_rpad_and_clip_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[uint32_t]], length: int64_t, target: int64_t)#
def awkward_ListOffsetArray_rpad_and_clip_axis1(toindex, fromoffsets, length, target):
for i in range(length):
rangeval = fromoffsets[i + 1] - fromoffsets[i]
shorter = target if target < rangeval else rangeval
for j in range(shorter):
toindex[(i * target) + j] = fromoffsets[i] + j
for j in range(shorter, target):
toindex[(i * target) + j] = -1
awkward_ListOffsetArray_rpad_axis1#
- awkward_ListOffsetArray32_rpad_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int32_t]], fromlength: int64_t, target: int64_t)#
- awkward_ListOffsetArray64_rpad_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int64_t]], fromlength: int64_t, target: int64_t)#
- awkward_ListOffsetArrayU32_rpad_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[uint32_t]], fromlength: int64_t, target: int64_t)#
def awkward_ListOffsetArray_rpad_axis1(toindex, fromoffsets, fromlength, target):
count = 0
for i in range(fromlength):
rangeval = fromoffsets[i + 1] - fromoffsets[i]
for j in range(rangeval):
toindex[count] = fromoffsets[i] + j
count = count + 1
for j in range(rangeval, target):
toindex[count] = -1
count = count + 1
awkward_ListOffsetArray_rpad_length_axis1#
- awkward_ListOffsetArray32_rpad_length_axis1(tooffsets: List[int32_t], fromoffsets: Const[List[int32_t]], fromlength: int64_t, target: int64_t, tolength: List[int64_t])#
- awkward_ListOffsetArray64_rpad_length_axis1(tooffsets: List[int64_t], fromoffsets: Const[List[int64_t]], fromlength: int64_t, target: int64_t, tolength: List[int64_t])#
- awkward_ListOffsetArrayU32_rpad_length_axis1(tooffsets: List[uint32_t], fromoffsets: Const[List[uint32_t]], fromlength: int64_t, target: int64_t, tolength: List[int64_t])#
def awkward_ListOffsetArray_rpad_length_axis1(
tooffsets, fromoffsets, fromlength, target, tolength
):
length = 0
tooffsets[0] = 0
for i in range(fromlength):
rangeval = fromoffsets[i + 1] - fromoffsets[i]
longer = rangeval if target < rangeval else target
length = length + longer
tooffsets[i + 1] = tooffsets[i] + longer
tolength[0] = length
awkward_ListOffsetArray_toRegularArray#
- awkward_ListOffsetArray32_toRegularArray(size: List[int64_t], fromoffsets: Const[List[int32_t]], offsetslength: int64_t)#
- awkward_ListOffsetArray64_toRegularArray(size: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t)#
- awkward_ListOffsetArrayU32_toRegularArray(size: List[int64_t], fromoffsets: Const[List[uint32_t]], offsetslength: int64_t)#
def awkward_ListOffsetArray_toRegularArray(size, fromoffsets, offsetslength):
size[0] = -1
for i in range(offsetslength - 1):
count = int(fromoffsets[i + 1]) - int(fromoffsets[i])
if count < 0:
raise ValueError("offsets must be monotonically increasing")
if size[0] == -1:
size[0] = count
else:
if size[0] != count:
raise ValueError(
"cannot convert to RegularArray because subarray lengths are not regular"
)
if size[0] == -1:
size[0] = 0
awkward_MaskedArray_getitem_next_jagged_project#
- awkward_MaskedArray32_getitem_next_jagged_project(index: List[int32_t], starts_in: List[int64_t], stops_in: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)#
- awkward_MaskedArray64_getitem_next_jagged_project(index: List[int64_t], starts_in: List[int64_t], stops_in: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)#
- awkward_MaskedArrayU32_getitem_next_jagged_project(index: List[uint32_t], starts_in: List[int64_t], stops_in: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)#
def awkward_MaskedArray_getitem_next_jagged_project(
index, starts_in, stops_in, starts_out, stops_out, length
):
k = 0
for i in range(length):
if index[i] >= 0:
starts_out[k] = starts_in[i]
stops_out[k] = stops_in[i]
k = k + 1
awkward_NumpyArray_rearrange_shifted#
- awkward_NumpyArray_rearrange_shifted_toint64_fromint64(toptr: List[int64_t], fromshifts: Const[List[int64_t]], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromparents: Const[List[int64_t]], fromstarts: Const[List[int64_t]])#
def awkward_NumpyArray_rearrange_shifted(toptr, fromshifts, length, fromoffsets, offsetslength, fromparents, fromstarts):
k = 0
for i in range(offsetslength - 1):
for j in range(fromoffsets[i + 1] - fromoffsets[i]):
toptr[k] = toptr[k] + fromoffsets[i]
k = k + 1
for i in range(length):
parent = fromparents[i]
start = fromstarts[parent]
toptr[i] = toptr[i] + fromshifts[toptr[i]] - start
awkward_NumpyArray_reduce_adjust_starts_64#
- awkward_NumpyArray_reduce_adjust_starts_64(toptr: List[int64_t], outlength: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])#
def awkward_NumpyArray_reduce_adjust_starts_64(toptr, outlength, parents, starts):
for k in range(outlength):
i = toptr[k]
if i >= 0:
parent = parents[i]
start = starts[parent]
toptr[k] += -start
awkward_NumpyArray_reduce_adjust_starts_shifts_64#
- awkward_NumpyArray_reduce_adjust_starts_shifts_64(toptr: List[int64_t], outlength: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]], shifts: Const[List[int64_t]])#
def awkward_NumpyArray_reduce_adjust_starts_shifts_64(
toptr, outlength, parents, starts, shifts
):
for k in range(outlength):
i = toptr[k]
if i >= 0:
parent = parents[i]
start = starts[parent]
toptr[k] += shifts[i] - start
awkward_NumpyArray_reduce_mask_ByteMaskedArray_64#
- awkward_NumpyArray_reduce_mask_ByteMaskedArray_64(toptr: List[int8_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_NumpyArray_reduce_mask_ByteMaskedArray_64(
toptr, parents, lenparents, outlength
):
for i in range(outlength):
toptr[i] = 1
for i in range(lenparents):
toptr[parents[i]] = 0
awkward_ListOffsetArray_argsort_strings#
- awkward_ListOffsetArray_argsort_strings(tocarry: List[int64_t], fromparents: Const[List[int64_t]], length: int64_t, stringdata: Const[List[uint8_t]], stringstarts: Const[List[int64_t]], stringstops: Const[List[int64_t]], is_stable: bool, is_ascending: bool, is_local: bool)#
Insert Python definition here
awkward_NumpyArray_sort_asstrings_uint8#
- awkward_NumpyArray_sort_asstrings_uint8(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], ascending: bool, stable: bool)#
Insert Python definition here
awkward_NumpyArray_unique_strings#
- awkward_NumpyArray_unique_strings_uint8(toptr: List[uint8_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])#
Insert Python definition here
awkward_NumpyArray_prepare_utf8_to_utf32_padded#
- awkward_NumpyArray_prepare_utf8_to_utf32_padded(fromptr: Const[List[uint8_t]], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, outmaxcodepoints: List[int64_t])#
Insert Python definition here
awkward_NumpyArray_utf8_to_utf32_padded#
- awkward_NumpyArray_utf8_to_utf32_padded(fromptr: Const[List[uint8_t]], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, maxcodepoints: int64_t, toptr: List[uint32_t])#
Insert Python definition here
awkward_NumpyArray_pad_zero_to_length#
- awkward_NumpyArray_pad_zero_to_length_uint8(fromptr: Const[List[uint8_t]], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, target: int64_t, toptr: List[uint8_t])#
def awkward_NumpyArray_pad_zero_to_length(
fromptr, fromoffsets, offsetslength, target, toptr
):
l_to_char = 0
# For each sublist
for k_sublist in range(offsetslength - 1):
# Copy from src to dst
for j_from_char in range(fromoffsets[k_sublist], fromoffsets[k_sublist + 1]):
toptr[l_to_char] = fromptr[j_from_char]
l_to_char += 1
# Pad to remaining width
n_to_pad = target - (fromoffsets[k_sublist + 1] - fromoffsets[k_sublist])
for j_from_char in range(n_to_pad):
toptr[l_to_char] = 0
l_to_char += 1
awkward_NumpyArray_subrange_equal_bool#
- awkward_NumpyArray_subrange_equal_bool(tmpptr: List[bool], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
def awkward_NumpyArray_subrange_equal_bool(
tmpptr, fromstarts, fromstops, length, toequal
):
differ = True
for i in range(length - 1):
leftlen = fromstops[i] - fromstarts[i]
for ii in range(i + 1, length - 1):
rightlen = fromstops[ii] - fromstarts[ii]
if leftlen == rightlen:
differ = False
for j in range (leftlen):
if (tmpptr[fromstarts[i] + j] != 0) != (tmpptr[fromstarts[ii] + j] != 0):
differ = True
break
toequal[0] = not differ
awkward_NumpyArray_subrange_equal#
- awkward_NumpyArray_subrange_equal_int8(tmpptr: List[int8_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_int16(tmpptr: List[int16_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_int32(tmpptr: List[int32_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_int64(tmpptr: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_uint8(tmpptr: List[uint8_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_uint16(tmpptr: List[uint16_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_uint32(tmpptr: List[uint32_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_uint64(tmpptr: List[uint64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_float32(tmpptr: List[float], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
- awkward_NumpyArray_subrange_equal_float64(tmpptr: List[double], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
def awkward_NumpyArray_subrange_equal(
tmpptr, fromstarts, fromstops, length, toequal
):
differ = True
for i in range(length - 1):
leftlen = fromstops[i] - fromstarts[i]
for ii in range(i + 1, length - 1):
rightlen = fromstops[ii] - fromstarts[ii]
if leftlen == rightlen:
differ = False
for j in range (leftlen):
if tmpptr[fromstarts[i] + j] != tmpptr[fromstarts[ii] + j]:
differ = True
break
toequal[0] = not differ
awkward_RecordArray_reduce_nonlocal_outoffsets_64#
- awkward_RecordArray_reduce_nonlocal_outoffsets_64(outoffsets: List[int64_t], outcarry: List[int64_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_RecordArray_reduce_nonlocal_outoffsets_64(
outoffsets, outcarry, parents, lenparents, outlength
):
# Zero initialise offsets
outoffsets[0] = 0
# Initialise carry to unique value, indicating "missing"
for i in range(outlength):
outcarry[i] = -1
# Fill offsets with lengths of sublists (in order of appearance, *NOT* parents)
i = 0
k_sublist = 0
for j in range(1, lenparents):
if parents[i] != parents[j]:
outoffsets[k_sublist + 1] = j
outcarry[parents[i]] = k_sublist
i = j
k_sublist += 1
# Close open sublist
if lenparents > 0:
outoffsets[k_sublist + 1] = j + 1
outcarry[parents[i]] = k_sublist
k_sublist += 1
# Append empty lists for missing parents
for i in range(k_sublist, outlength):
outoffsets[i + 1] = lenparents
# Replace unique value with index of appended empty list
for i in range(outlength):
if outcarry[i] == -1:
outcarry[i] = k_sublist
k_sublist += 1
awkward_RegularArray_combinations_64#
- awkward_RegularArray_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, size: int64_t, length: int64_t)#
def awkward_RegularArray_combinations_64(
tocarry, toindex, fromindex, n, replacement, size, length
):
for j in range(n):
toindex[j] = 0
for i in range(length):
start = size * i
stop = start + size
fromindex[0] = start
awkward_ListArray_combinations_step(
tocarry, toindex, fromindex, 0, stop, n, replacement
)
awkward_RegularArray_getitem_carry#
- awkward_RegularArray_getitem_carry_64(tocarry: List[int64_t], fromcarry: Const[List[int64_t]], lencarry: int64_t, size: int64_t)#
def awkward_RegularArray_getitem_carry(tocarry, fromcarry, lencarry, size):
for i in range(lencarry):
for j in range(size):
tocarry[(i * size) + j] = (fromcarry[i] * size) + j
awkward_RegularArray_getitem_jagged_expand#
- awkward_RegularArray_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], regularsize: int64_t, regularlength: int64_t)#
def awkward_RegularArray_getitem_jagged_expand(
multistarts, multistops, singleoffsets, regularsize, regularlength
):
for i in range(regularlength):
for j in range(regularsize):
multistarts[(i * regularsize) + j] = singleoffsets[j]
multistops[(i * regularsize) + j] = singleoffsets[j + 1]
awkward_RegularArray_getitem_next_array#
- awkward_RegularArray_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromarray: Const[List[int64_t]], length: int64_t, lenarray: int64_t, size: int64_t)#
def awkward_RegularArray_getitem_next_array(
tocarry, toadvanced, fromarray, length, lenarray, size
):
for i in range(length):
for j in range(lenarray):
tocarry[(i * lenarray) + j] = (i * size) + fromarray[j]
toadvanced[(i * lenarray) + j] = j
awkward_RegularArray_getitem_next_array_advanced#
- awkward_RegularArray_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromarray: Const[List[int64_t]], length: int64_t, size: int64_t)#
def awkward_RegularArray_getitem_next_array_advanced(
tocarry, toadvanced, fromadvanced, fromarray, length, size
):
for i in range(length):
tocarry[i] = (i * size) + fromarray[fromadvanced[i]]
toadvanced[i] = i
awkward_RegularArray_getitem_next_array_regularize#
- awkward_RegularArray_getitem_next_array_regularize_64(toarray: List[int64_t], fromarray: Const[List[int64_t]], lenarray: int64_t, size: int64_t)#
def awkward_RegularArray_getitem_next_array_regularize(
toarray, fromarray, lenarray, size
):
for j in range(lenarray):
toarray[j] = fromarray[j]
if toarray[j] < 0:
toarray[j] += size
if not ((0 <= toarray[j]) and (toarray[j] < size)):
raise ValueError("index out of range")
awkward_RegularArray_getitem_next_at#
- awkward_RegularArray_getitem_next_at_64(tocarry: List[int64_t], at: int64_t, length: int64_t, size: int64_t)#
def awkward_RegularArray_getitem_next_at(tocarry, at, length, size):
regular_at = at
if regular_at < 0:
regular_at += size
if not ((0 <= regular_at) and (regular_at < size)):
raise ValueError("index out of range")
for i in range(length):
tocarry[i] = (i * size) + regular_at
awkward_RegularArray_getitem_next_range#
- awkward_RegularArray_getitem_next_range_64(tocarry: List[int64_t], regular_start: int64_t, step: int64_t, length: int64_t, size: int64_t, nextsize: int64_t)#
def awkward_RegularArray_getitem_next_range(
tocarry, regular_start, step, length, size, nextsize
):
for i in range(length):
for j in range(nextsize):
tocarry[(i * nextsize) + j] = ((i * size) + regular_start) + (j * step)
awkward_RegularArray_getitem_next_range_spreadadvanced#
- awkward_RegularArray_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], length: int64_t, nextsize: int64_t)#
def awkward_RegularArray_getitem_next_range_spreadadvanced(
toadvanced, fromadvanced, length, nextsize
):
for i in range(length):
for j in range(nextsize):
toadvanced[(i * nextsize) + j] = fromadvanced[i]
awkward_RegularArray_localindex#
- awkward_RegularArray_localindex_64(toindex: List[int64_t], size: int64_t, length: int64_t)#
def awkward_RegularArray_localindex(toindex, size, length):
for i in range(length):
for j in range(size):
toindex[(i * size) + j] = j
awkward_RegularArray_reduce_local_nextparents_64#
- awkward_RegularArray_reduce_local_nextparents_64(nextparents: List[int64_t], size: int64_t, length: int64_t)#
def awkward_RegularArray_reduce_local_nextparents_64(nextparents, size, length):
k = 0
for i in range(length):
for _ in range(size):
# nextparents should contain the row index
nextparents[k] = i
k += 1
awkward_RegularArray_reduce_nonlocal_preparenext_64#
- awkward_RegularArray_reduce_nonlocal_preparenext_64(nextcarry: List[int64_t], nextparents: List[int64_t], parents: Const[List[int64_t]], size: int64_t, length: int64_t)#
def awkward_RegularArray_reduce_nonlocal_preparenext_64(nextcarry, nextparents, parents, size, length):
k = 0
for j in range(size):
for i in range(length):
# nextparents needs to be locally contiguous
# so order our arrays by the transpose
nextcarry[k] = i * size + j
nextparents[k] = parents[i] * size + j
k += 1
awkward_RegularArray_rpad_and_clip_axis1#
- awkward_RegularArray_rpad_and_clip_axis1_64(toindex: List[int64_t], target: int64_t, size: int64_t, length: int64_t)#
def awkward_RegularArray_rpad_and_clip_axis1(toindex, target, size, length):
shorter = target if target < size else size
for i in range(length):
for j in range(shorter):
toindex[(i * target) + j] = (i * size) + j
for j in range(shorter, target):
toindex[(i * target) + j] = -1
awkward_UnionArray_fillindex#
- awkward_UnionArray_fillindex_to64_from32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int32_t]], length: int64_t)#
- awkward_UnionArray_fillindex_to64_from64(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int64_t]], length: int64_t)#
- awkward_UnionArray_fillindex_to64_fromU32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[uint32_t]], length: int64_t)#
def awkward_UnionArray_fillindex(toindex, toindexoffset, fromindex, length):
for i in range(length):
toindex[toindexoffset + i] = fromindex[i]
awkward_UnionArray_fillindex_count#
- awkward_UnionArray_fillindex_to64_count(toindex: List[int64_t], toindexoffset: int64_t, length: int64_t)#
def awkward_UnionArray_fillindex_count(toindex, toindexoffset, length):
for i in range(length):
toindex[toindexoffset + i] = i
awkward_UnionArray_fillna#
- awkward_UnionArray_fillna_from32_to64(toindex: List[int64_t], fromindex: Const[List[int32_t]], length: int64_t)#
- awkward_UnionArray_fillna_from64_to64(toindex: List[int64_t], fromindex: Const[List[int64_t]], length: int64_t)#
- awkward_UnionArray_fillna_fromU32_to64(toindex: List[int64_t], fromindex: Const[List[uint32_t]], length: int64_t)#
def awkward_UnionArray_fillna(toindex, fromindex, length):
for i in range(length):
toindex[i] = fromindex[i] if fromindex[i] >= 0 else 0
awkward_UnionArray_flatten_combine#
- awkward_UnionArray32_flatten_combine_64(totags: List[int8_t], toindex: List[int64_t], tooffsets: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t, offsetsraws: List[List[int64_t]])#
- awkward_UnionArray64_flatten_combine_64(totags: List[int8_t], toindex: List[int64_t], tooffsets: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t, offsetsraws: List[List[int64_t]])#
- awkward_UnionArrayU32_flatten_combine_64(totags: List[int8_t], toindex: List[int64_t], tooffsets: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t, offsetsraws: List[List[int64_t]])#
def awkward_UnionArray_flatten_combine(
totags, toindex, tooffsets, fromtags, fromindex, length, offsetsraws
):
tooffsets[0] = 0
k = 0
for i in range(length):
tag = fromtags[i]
idx = fromindex[i]
start = offsetsraws[tag][idx]
stop = offsetsraws[tag][idx + 1]
tooffsets[i + 1] = tooffsets[i] + (stop - start)
for j in range(start, stop):
totags[k] = tag
toindex[k] = j
k = k + 1
awkward_UnionArray_flatten_length#
- awkward_UnionArray32_flatten_length_64(total_length: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t, offsetsraws: List[List[int64_t]])#
- awkward_UnionArray64_flatten_length_64(total_length: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t, offsetsraws: List[List[int64_t]])#
- awkward_UnionArrayU32_flatten_length_64(total_length: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t, offsetsraws: List[List[int64_t]])#
def awkward_UnionArray_flatten_length(
total_length, fromtags, fromindex, length, offsetsraws
):
total_length[0] = 0
for i in range(length):
tag = fromtags[i]
idx = fromindex[i]
start = offsetsraws[tag][idx]
stop = offsetsraws[tag][idx + 1]
total_length[0] = total_length[0] + (stop - start)
awkward_UnionArray_project#
- awkward_UnionArray8_32_project_64(lenout: List[int64_t], tocarry: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t, which: int64_t)#
- awkward_UnionArray8_64_project_64(lenout: List[int64_t], tocarry: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t, which: int64_t)#
- awkward_UnionArray8_U32_project_64(lenout: List[int64_t], tocarry: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t, which: int64_t)#
def awkward_UnionArray_project(lenout, tocarry, fromtags, fromindex, length, which):
lenout[0] = 0
for i in range(length):
if fromtags[i] == which:
tocarry[lenout[0]] = fromindex[i]
lenout[0] = lenout[0] + 1
awkward_UnionArray_regular_index#
- awkward_UnionArray8_32_regular_index(toindex: List[int32_t], current: List[int32_t], size: int64_t, fromtags: Const[List[int8_t]], length: int64_t)#
- awkward_UnionArray8_64_regular_index(toindex: List[int64_t], current: List[int64_t], size: int64_t, fromtags: Const[List[int8_t]], length: int64_t)#
- awkward_UnionArray8_U32_regular_index(toindex: List[uint32_t], current: List[uint32_t], size: int64_t, fromtags: Const[List[int8_t]], length: int64_t)#
def awkward_UnionArray_regular_index(toindex, current, size, fromtags, length):
count = 0
for k in range(size):
current[k] = 0
for i in range(length):
tag = fromtags[i]
toindex[i] = current[tag]
current[tag] = current[tag] + 1
awkward_UnionArray_regular_index_getsize#
- awkward_UnionArray8_regular_index_getsize(size: List[int64_t], fromtags: Const[List[int8_t]], length: int64_t)#
def awkward_UnionArray_regular_index_getsize(size, fromtags, length):
size[0] = 0
for i in range(length):
tag = int(fromtags[i])
if size[0] < tag:
size[0] = tag
size[0] = size[0] + 1
awkward_UnionArray_simplify#
- awkward_UnionArray64_64_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int64_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_32_simplify8_32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_32_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_32_simplify8_U32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[uint32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_64_simplify8_32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_64_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_64_simplify8_U32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[uint32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_U32_simplify8_32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[uint32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_U32_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[uint32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_U32_simplify8_U32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[uint32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[uint32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)#
def awkward_UnionArray_simplify(
totags,
toindex,
outertags,
outerindex,
innertags,
innerindex,
towhich,
innerwhich,
outerwhich,
length,
base,
):
for i in range(length):
if outertags[i] == outerwhich:
j = outerindex[i]
if innertags[j] == innerwhich:
totags[i] = towhich
toindex[i] = innerindex[j] + base
awkward_UnionArray_simplify_one#
- awkward_UnionArray64_64_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int64_t]], fromindex: Const[List[int64_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_32_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_64_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)#
- awkward_UnionArray8_U32_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)#
def awkward_UnionArray_simplify_one(
totags, toindex, fromtags, fromindex, towhich, fromwhich, length, base
):
for i in range(length):
if fromtags[i] == fromwhich:
totags[i] = towhich
toindex[i] = fromindex[i] + base
awkward_UnionArray_validity#
- awkward_UnionArray8_32_validity(tags: Const[List[int8_t]], index: Const[List[int32_t]], length: int64_t, numcontents: int64_t, lencontents: Const[List[int64_t]])#
- awkward_UnionArray8_64_validity(tags: Const[List[int8_t]], index: Const[List[int64_t]], length: int64_t, numcontents: int64_t, lencontents: Const[List[int64_t]])#
- awkward_UnionArray8_U32_validity(tags: Const[List[int8_t]], index: Const[List[uint32_t]], length: int64_t, numcontents: int64_t, lencontents: Const[List[int64_t]])#
def awkward_UnionArray_validity(tags, index, length, numcontents, lencontents):
for i in range(length):
tag = tags[i]
idx = index[i]
if tag < 0:
raise ValueError("tags[i] < 0")
if idx < 0:
raise ValueError("index[i] < 0")
if tag >= numcontents:
raise ValueError("tags[i] >= len(contents)")
lencontent = lencontents[tag]
if idx >= lencontent:
raise ValueError("index[i] >= len(content[tags[i]])")
awkward_argsort#
- awkward_argsort_bool(toptr: List[int64_t], fromptr: Const[List[bool]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_int8(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_int16(toptr: List[int64_t], fromptr: Const[List[int16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_int32(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_uint8(toptr: List[int64_t], fromptr: Const[List[uint8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_uint16(toptr: List[int64_t], fromptr: Const[List[uint16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_uint32(toptr: List[int64_t], fromptr: Const[List[uint32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_uint64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_float32(toptr: List[int64_t], fromptr: Const[List[float]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
- awkward_argsort_float64(toptr: List[int64_t], fromptr: Const[List[double]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)#
def awkward_argsort(
toptr, fromptr, length, offsets, offsetslength, ascending, stable
):
result = []
indices = list(range(length))
for i in range(offsetslength - 1):
sub_indices = indices[offsets[i]:offsets[i+1]]
sorted_indices = sorted(
sub_indices,
key=lambda x: fromptr[x],
reverse=not ascending
)
local_sorted_indices = [idx - offsets[i] for idx in sorted_indices]
result.extend(local_sorted_indices)
for i in range(length):
toptr[i] = result[i]
awkward_index_rpad_and_clip_axis0#
- awkward_index_rpad_and_clip_axis0_64(toindex: List[int64_t], target: int64_t, length: int64_t)#
def awkward_index_rpad_and_clip_axis0(toindex, target, length):
shorter = target if target < length else length
for i in range(shorter):
toindex[i] = i
for i in range(shorter, target):
toindex[i] = -1
awkward_index_rpad_and_clip_axis1#
- awkward_index_rpad_and_clip_axis1_64(tostarts: List[int64_t], tostops: List[int64_t], target: int64_t, length: int64_t)#
def awkward_index_rpad_and_clip_axis1(tostarts, tostops, target, length):
offset = 0
for i in range(length):
tostarts[i] = offset
offset = offset + target
tostops[i] = offset
awkward_Index_nones_as_index#
- awkward_Index_nones_as_index_64(toindex: List[int64_t], length: int64_t)#
def awkward_Index_nones_as_index(toindex, length):
num_non_null = 0
for i in range(length):
if toindex[i] != -1:
num_non_null += 1
for i in range(length):
if toindex[i] == -1:
toindex[i] = num_non_null
num_non_null += 1
awkward_localindex#
- awkward_localindex_64(toindex: List[int64_t], length: int64_t)#
def awkward_localindex(toindex, length):
for i in range(length):
toindex[i] = i
awkward_missing_repeat#
- awkward_missing_repeat_64(outindex: List[int64_t], index: Const[List[int64_t]], indexlength: int64_t, repetitions: int64_t, regularsize: int64_t)#
def awkward_missing_repeat(outindex, index, indexlength, repetitions, regularsize):
for i in range(repetitions):
for j in range(indexlength):
base = index[j]
outindex[(i * indexlength) + j] = base + i * regularsize if base >= 0 else 0
awkward_reduce_argmax#
- awkward_reduce_argmax_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_uint8_64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_uint16_64(toptr: List[int64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_uint32_64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_uint64_64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_float32_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_float64_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_argmax(toptr, fromptr, parents, lenparents, outlength):
for k in range(outlength):
toptr[k] = -1
for i in range(lenparents):
parent = parents[i]
if (toptr[parent] == -1) or (fromptr[i] > fromptr[toptr[parent]]):
toptr[parent] = i
awkward_reduce_argmax_complex#
- awkward_reduce_argmax_complex64_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmax_complex128_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_argmax_complex(toptr, fromptr, parents, lenparents, outlength):
for k in range(outlength):
toptr[k] = -1
for i in range(lenparents):
parent = parents[i]
if (toptr[parent] == -1 or (fromptr[i * 2] > fromptr[toptr[parent] * 2] or
(fromptr[i * 2] == fromptr[toptr[parent] * 2] and
fromptr[i * 2 + 1] > fromptr[toptr[parent] * 2 + 1]))):
toptr[parent] = i
awkward_reduce_argmin#
- awkward_reduce_argmin_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_uint8_64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_uint16_64(toptr: List[int64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_uint32_64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_uint64_64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_float32_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_float64_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_argmin(toptr, fromptr, parents, lenparents, outlength):
for k in range(outlength):
toptr[k] = -1
for i in range(lenparents):
parent = parents[i]
if (toptr[parent] == -1) or (fromptr[i] < fromptr[toptr[parent]]):
toptr[parent] = i
awkward_reduce_argmin_complex#
- awkward_reduce_argmin_complex64_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_argmin_complex128_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_argmin_complex(toptr, fromptr, parents, lenparents, outlength):
for k in range(outlength):
toptr[k] = -1
for i in range(lenparents):
parent = parents[i]
if (toptr[parent] == -1 or (fromptr[i * 2] < fromptr[toptr[parent] * 2] or
(fromptr[i * 2] == fromptr[toptr[parent] * 2] and
fromptr[i * 2 + 1] < fromptr[toptr[parent] * 2 + 1]))):
toptr[parent] = i
awkward_reduce_count_64#
- awkward_reduce_count_64(toptr: List[int64_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_count_64(toptr, parents, lenparents, outlength):
for i in range(outlength):
toptr[i] = 0
for i in range(lenparents):
toptr[parents[i]] = toptr[parents[i]] + 1
awkward_reduce_countnonzero#
- awkward_reduce_countnonzero_bool_64(toptr: List[int64_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_uint8_64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_uint16_64(toptr: List[int64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_uint32_64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_uint64_64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_float32_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_float64_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_countnonzero(toptr, fromptr, parents, lenparents, outlength):
for i in range(outlength):
toptr[i] = 0
for i in range(lenparents):
toptr[parents[i]] += fromptr[i] != 0
awkward_reduce_countnonzero_complex#
- awkward_reduce_countnonzero_complex64_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
- awkward_reduce_countnonzero_complex128_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)#
def awkward_reduce_countnonzero_complex(toptr, fromptr, parents, lenparents, outlength):
for i in range(outlength):
toptr[i] = 0
for i in range(lenparents):
toptr[parents[i]] += fromptr[i * 2] != 0 or fromptr[i * 2 + 1] != 0
awkward_reduce_max#
- awkward_reduce_max_int8_int8_64(toptr: List[int8_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int8_t)#
- awkward_reduce_max_int16_int16_64(toptr: List[int16_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int16_t)#
- awkward_reduce_max_int32_int32_64(toptr: List[int32_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int32_t)#
- awkward_reduce_max_int64_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int64_t)#
- awkward_reduce_max_uint8_uint8_64(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint8_t)#
- awkward_reduce_max_uint16_uint16_64(toptr: List[uint16_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint16_t)#
- awkward_reduce_max_uint32_uint32_64(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint32_t)#
- awkward_reduce_max_uint64_uint64_64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint64_t)#
- awkward_reduce_max_float32_float32_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: float)#
- awkward_reduce_max_float64_float64_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: double)#
def awkward_reduce_max(toptr, fromptr, parents, lenparents, outlength, identity):
for i in range(outlength):
toptr[i] = identity
for i in range(lenparents):
x = fromptr[i]
toptr[parents[i]] = x if x > toptr[parents[i]] else toptr[parents[i]]
awkward_reduce_max_complex#
- awkward_reduce_max_complex64_complex64_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: float)#
-
awkward_reduce_max_complex128_complex128_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: