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 <<= 1
            tobytemask[(i * 8) + 1] = ((byte & uint8(128)) != 0) != validwhen
            byte <<= 1
            tobytemask[(i * 8) + 2] = ((byte & uint8(128)) != 0) != validwhen
            byte <<= 1
            tobytemask[(i * 8) + 3] = ((byte & uint8(128)) != 0) != validwhen
            byte <<= 1
            tobytemask[(i * 8) + 4] = ((byte & uint8(128)) != 0) != validwhen
            byte <<= 1
            tobytemask[(i * 8) + 5] = ((byte & uint8(128)) != 0) != validwhen
            byte <<= 1
            tobytemask[(i * 8) + 6] = ((byte & uint8(128)) != 0) != validwhen
            byte <<= 1
            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 <<= 1
            if ((byte & uint8(128)) != 0) == validwhen:
                toindex[(i * 8) + 1] = (i * 8) + 1
            else:
                toindex[(i * 8) + 1] = -1
            byte <<= 1
            if ((byte & uint8(128)) != 0) == validwhen:
                toindex[(i * 8) + 2] = (i * 8) + 2
            else:
                toindex[(i * 8) + 2] = -1
            byte <<= 1
            if ((byte & uint8(128)) != 0) == validwhen:
                toindex[(i * 8) + 3] = (i * 8) + 3
            else:
                toindex[(i * 8) + 3] = -1
            byte <<= 1
            if ((byte & uint8(128)) != 0) == validwhen:
                toindex[(i * 8) + 4] = (i * 8) + 4
            else:
                toindex[(i * 8) + 4] = -1
            byte <<= 1
            if ((byte & uint8(128)) != 0) == validwhen:
                toindex[(i * 8) + 5] = (i * 8) + 5
            else:
                toindex[(i * 8) + 5] = -1
            byte <<= 1
            if ((byte & uint8(128)) != 0) == validwhen:
                toindex[(i * 8) + 6] = (i * 8) + 6
            else:
                toindex[(i * 8) + 6] = -1
            byte <<= 1
            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] = float(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 float(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] = float(k)
                k = k + 1

awkward_IndexedArray_local_preparenext#

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])#
Insert Python definition here

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 = 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] = float(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)#
Insert Python definition here

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] = float(fromstarts[i] + base)
        tostops[tostopsoffset + i] = float(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] = float(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[i + 1] = float(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] + float(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):
                numvalid[0] = numvalid[0] + 1 if missing[j] >= 0 else 0

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, lenarray: 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, lenarray: 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, lenarray: int64_t, lencontent: int64_t)#
def awkward_ListArray_getitem_next_array_advanced(
    tocarry,
    toadvanced,
    fromstarts,
    fromstops,
    fromarray,
    fromadvanced,
    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]
        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
    if step > 0:
        for i in range(lenstarts):
            length = fromstops[i] - fromstarts[i]
            regular_start = start
            regular_stop = stop
            awkward_regularize_rangeslice(
                regular_start,
                regular_stop,
                step > 0,
                start != kSliceNone,
                stop != kSliceNone,
                length,
            )
            j = regular_start
            while j < regular_stop:
                tocarry[k] = fromstarts[i] + j
                k = k + 1
                j += step
            tooffsets[i + 1] = float(k)
    else:
        for i in range(lenstarts):
            length = fromstops[i] - fromstarts[i]
            regular_start = start
            regular_stop = stop
            awkward_regularize_rangeslice(
                regular_start,
                regular_stop,
                step > 0,
                start != kSliceNone,
                stop != kSliceNone,
                length,
            )
            j = regular_start
            while j > regular_stop:
                tocarry[k] = fromstarts[i] + j
                k = k + 1
                j += step
            tooffsets[i + 1] = float(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
        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):
    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_compact_offsets#

awkward_ListOffsetArray32_compact_offsets_64(tooffsets: List[int64_t], fromoffsets: Const[List[int32_t]], length: int64_t)#
awkward_ListOffsetArray64_compact_offsets_64(tooffsets: List[int64_t], fromoffsets: Const[List[int64_t]], length: int64_t)#
awkward_ListOffsetArrayU32_compact_offsets_64(tooffsets: List[int64_t], fromoffsets: Const[List[uint32_t]], length: int64_t)#
def awkward_ListOffsetArray_compact_offsets(tooffsets, fromoffsets, length):
    diff = int(fromoffsets[0])
    tooffsets[0] = 0
    for i in range(length):
        tooffsets[i + 1] = fromoffsets[i + 1] - diff

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]], inneroffsetslen: int64_t)#
awkward_ListOffsetArray64_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[int64_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]], inneroffsetslen: int64_t)#
awkward_ListOffsetArrayU32_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[uint32_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]], inneroffsetslen: int64_t)#
def awkward_ListOffsetArray_flatten_offsets(
    tooffsets, outeroffsets, outeroffsetslen, inneroffsets, inneroffsetslen
):
    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)#
Insert Python definition here

awkward_ListOffsetArray_reduce_local_nextparents_64#

awkward_ListOffsetArray_reduce_local_nextparents_64(nextparents: List[int64_t], offsets: Const[List[int64_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)#
Insert Python definition here

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 = float(fromoffsets[i + 1] - fromoffsets[i])
        shorter = target if target < rangeval else rangeval
        for j in range(shorter):
            toindex[(i * target) + j] = float(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 = float(fromoffsets[i + 1] - fromoffsets[i])
        for j in range(rangeval):
            toindex[count] = float(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_fill#

awkward_NumpyArray_fill_toint8_fromint8(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromint16(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromint32(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromint64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromuint8(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromuint16(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromuint32(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromuint64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromfloat32(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_toint8_fromfloat64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromint8(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromint16(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromint32(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromint64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromuint8(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromuint16(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromuint32(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromuint64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromfloat32(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_toint16_fromfloat64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromint8(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromint16(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromint32(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromint64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromuint8(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromuint16(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromuint32(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromuint64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromfloat32(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_toint32_fromfloat64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromint8(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromint16(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromint32(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromint64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromuint8(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromuint16(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromuint32(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromuint64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromfloat32(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_toint64_fromfloat64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromint8(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromint16(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromint32(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromint64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromuint8(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromuint16(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromuint32(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromuint64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromfloat32(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_touint8_fromfloat64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromint8(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromint16(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromint32(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromint64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromuint8(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromuint16(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromuint32(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromuint64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromfloat32(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_touint16_fromfloat64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromint8(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromint16(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromint32(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromint64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromuint8(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromuint16(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromuint32(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromuint64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromfloat32(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_touint32_fromfloat64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromint8(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromint16(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromint32(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromint64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromuint8(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromuint16(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromuint32(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromuint64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromfloat32(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_touint64_fromfloat64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromint8(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromint16(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromint32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromint64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromuint8(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromuint16(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromuint32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromuint64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromfloat32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_tofloat32_fromfloat64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromint8(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromint16(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromint32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromint64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromuint8(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromuint16(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromuint32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromuint64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromfloat32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)#
awkward_NumpyArray_fill_tofloat64_fromfloat64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)#
def awkward_NumpyArray_fill(toptr, tooffset, fromptr, length):
    for i in range(length):
        toptr[tooffset + i] = float(fromptr[i])

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]], parentslength: int64_t, fromstarts: Const[List[int64_t]], startslength: int64_t)#
def awkward_NumpyArray_rearrange_shifted(toptr, fromshifts, length, fromoffsets, offsetslength, fromparents, parentslength):
    k = 0
    for i in range(offsetslength - 1):
        for j in rage(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_subrange_equal#

awkward_NumpyArray_subrange_equal_bool(tmpptr: List[bool], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])#
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])#
Insert Python definition here

awkward_RegularArray_broadcast_tooffsets#

awkward_RegularArray_broadcast_tooffsets_64(fromoffsets: Const[List[int64_t]], offsetslength: int64_t, size: int64_t)#
def awkward_RegularArray_broadcast_tooffsets(fromoffsets, offsetslength, size):
    for i in range(offsetslength - 1):
        count = int(fromoffsets[i + 1] - fromoffsets[i])
        if count < 0:
            raise ValueError("broadcast's offsets must be monotonically increasing")
        if size != count:
            raise ValueError("cannot broadcast nested list")

awkward_RegularArray_broadcast_tooffsets_size1#

awkward_RegularArray_broadcast_tooffsets_size1_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t)#
def awkward_RegularArray_broadcast_tooffsets_size1(tocarry, fromoffsets, offsetslength):
    k = 0
    for i in range(offsetslength - 1):
        count = int(fromoffsets[i + 1] - fromoffsets[i])
        if count < 0:
            raise ValueError("broadcast's offsets must be monotonically increasing")
        for j in range(count):
            tocarry[k] = float(i)
            k = k + 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)#
Insert Python definition here

awkward_RegularArray_compact_offsets#

awkward_RegularArray_compact_offsets64(tooffsets: List[int64_t], length: int64_t, size: int64_t)#
def awkward_RegularArray_compact_offsets(tooffsets, length, size):
    tooffsets[0] = 0
    for i in range(length):
        tooffsets[i + 1] = (i + 1) * size

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, lenarray: int64_t, size: int64_t)#
def awkward_RegularArray_getitem_next_array_advanced(
    tocarry, toadvanced, fromadvanced, fromarray, length, lenarray, 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#

awkward_RegularArray_reduce_local_nextparents_64(nextparents: List[int64_t], size: int64_t, length: int64_t)#
def awkward_RegularArray_reduce_local_nextparents(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#

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(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] = float(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] = float(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_filltags#

awkward_UnionArray_filltags_to8_from8(totags: List[int8_t], totagsoffset: int64_t, fromtags: Const[List[int8_t]], length: int64_t, base: int64_t)#
def awkward_UnionArray_filltags(totags, totagsoffset, fromtags, length, base):
    for i in range(length):
        totags[totagsoffset + i] = float(fromtags[i] + base)

awkward_UnionArray_filltags_const#

awkward_UnionArray_filltags_to8_const(totags: List[int8_t], totagsoffset: int64_t, length: int64_t, base: int64_t)#
def awkward_UnionArray_filltags_const(totags, totagsoffset, length, base):
    for i in range(length):
        totags[totagsoffset + i] = float(base)

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_nestedfill_tags_index#

awkward_UnionArray8_32_nestedfill_tags_index_64(totags: List[int8_t], toindex: List[int32_t], tmpstarts: List[int64_t], tag: int8_t, fromcounts: Const[List[int64_t]], length: int64_t)#
awkward_UnionArray8_64_nestedfill_tags_index_64(totags: List[int8_t], toindex: List[int64_t], tmpstarts: List[int64_t], tag: int8_t, fromcounts: Const[List[int64_t]], length: int64_t)#
awkward_UnionArray8_U32_nestedfill_tags_index_64(totags: List[int8_t], toindex: List[uint32_t], tmpstarts: List[int64_t], tag: int8_t, fromcounts: Const[List[int64_t]], length: int64_t)#
def awkward_UnionArray_nestedfill_tags_index(
    totags, toindex, tmpstarts, tag, fromcounts, length
):
    k = 0
    for i in range(length):
        start = tmpstarts[i]
        stop = start + fromcounts[i]
        for j in range(start, stop):
            totags[j] = tag
            toindex[j] = k
            k += 1
        tmpstarts[i] = stop

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_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] = float(towhich)
                toindex[i] = float(innerindex[j] + base)

awkward_UnionArray_simplify_one#

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] = float(towhich)
            toindex[i] = float(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)#
Insert Python definition here

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):
    last_index = 0
    for i in range(length):
        if toindex[i] > last_index:
            last_index = toindex[i]
    for i in range(length):
        if toindex[i