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

awkward_Index32_iscontiguous(result: List[bool], fromindex: Const[List[int32_t]], length: int64_t)#
awkward_Index64_iscontiguous(result: List[bool], fromindex: Const[List[int64_t]], length: int64_t)#
awkward_Index8_iscontiguous(result: List[bool], fromindex: Const[List[int8_t]], length: int64_t)#
awkward_IndexU32_iscontiguous(result: List[bool], fromindex: Const[List[uint32_t]], length: int64_t)#
awkward_IndexU8_iscontiguous(result: List[bool], fromindex: Const[List[uint8_t]], length: int64_t)#
def awkward_Index_iscontiguous(result, fromindex, length):
    result[0] = True
    expecting = 0
    for i in range(length):
        if fromindex[i] != expecting:
            result[0] = False
            return
        expecting += 1

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 <