src/cpu-kernels/identities.cpp

awkward_new_identities
----------------------------------------------------

for T in int:

    def awkward_new_identities(toptr: List[T], length: int):
        for i in range(length):
            toptr[i] = i
        return


awkward_new_identities32
----------------------------------------------------

def awkward_new_identities32(toptr: List[int], length: int):
    return awkward_new_identities(toptr, length)


awkward_new_identities64
----------------------------------------------------

def awkward_new_identities64(toptr: List[int], length: int):
    return awkward_new_identities(toptr, length)


awkward_identities32_to_identities64
----------------------------------------------------

def awkward_identities32_to_identities64(
    toptr: List[int], fromptr: List[int], length: int, width: int
):
    for i in range(length * width):
        toptr[i] = int(fromptr[i])
    return


awkward_identities_from_listoffsetarray
----------------------------------------------------

for ID in int:
    for T in int:

        def awkward_identities_from_listoffsetarray(
            toptr: List[ID],
            fromptr: List[ID],
            fromoffsets: List[T],
            fromptroffset: int,
            offsetsoffset: int,
            tolength: int,
            fromlength: int,
            fromwidth: int,
        ):
            globalstart = fromoffsets[offsetsoffset]
            globalstop = fromoffsets[offsetsoffset + fromlength]
            for k in range(globalstart * (fromwidth + 1)):
                toptr[k] = -1
            k = globalstop * (fromwidth + 1)
            while k < (tolength * (fromwidth + 1)):
                toptr[k] = -1
                k = k + 1
            for i in range(fromlength):
                start = fromoffsets[offsetsoffset + i]
                stop = fromoffsets[(offsetsoffset + i) + 1]
                if (start != stop) and (stop > tolength):
                    raise ValueError("max(stop) > len(content)")
                j = start
                while j < stop:
                    for k in range(fromwidth):
                        toptr[(j * (fromwidth + 1)) + k] = fromptr[
                            (fromptroffset + (i * fromwidth)) + k
                        ]
                    toptr[(j * (fromwidth + 1)) + fromwidth] = int(j - start)
                    j = j + 1
            return


awkward_identities32_from_listoffsetarray32
----------------------------------------------------

def awkward_identities32_from_listoffsetarray32(
    toptr: List[int],
    fromptr: List[int],
    fromoffsets: List[int],
    fromptroffset: int,
    offsetsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listoffsetarray(
        toptr,
        fromptr,
        fromoffsets,
        fromptroffset,
        offsetsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities32_from_listoffsetarrayU32
----------------------------------------------------

def awkward_identities32_from_listoffsetarrayU32(
    toptr: List[int],
    fromptr: List[int],
    fromoffsets: List[int],
    fromptroffset: int,
    offsetsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listoffsetarray(
        toptr,
        fromptr,
        fromoffsets,
        fromptroffset,
        offsetsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities32_from_listoffsetarray64
----------------------------------------------------

def awkward_identities32_from_listoffsetarray64(
    toptr: List[int],
    fromptr: List[int],
    fromoffsets: List[int],
    fromptroffset: int,
    offsetsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listoffsetarray(
        toptr,
        fromptr,
        fromoffsets,
        fromptroffset,
        offsetsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_listoffsetarray32
----------------------------------------------------

def awkward_identities64_from_listoffsetarray32(
    toptr: List[int],
    fromptr: List[int],
    fromoffsets: List[int],
    fromptroffset: int,
    offsetsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listoffsetarray(
        toptr,
        fromptr,
        fromoffsets,
        fromptroffset,
        offsetsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_listoffsetarrayU32
----------------------------------------------------

def awkward_identities64_from_listoffsetarrayU32(
    toptr: List[int],
    fromptr: List[int],
    fromoffsets: List[int],
    fromptroffset: int,
    offsetsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listoffsetarray(
        toptr,
        fromptr,
        fromoffsets,
        fromptroffset,
        offsetsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_listoffsetarray64
----------------------------------------------------

def awkward_identities64_from_listoffsetarray64(
    toptr: List[int],
    fromptr: List[int],
    fromoffsets: List[int],
    fromptroffset: int,
    offsetsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listoffsetarray(
        toptr,
        fromptr,
        fromoffsets,
        fromptroffset,
        offsetsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities_from_listarray
----------------------------------------------------

for ID in int:
    for T in int:

        def awkward_identities_from_listarray(
            uniquecontents: List[bool],
            toptr: List[ID],
            fromptr: List[ID],
            fromstarts: List[T],
            fromstops: List[T],
            fromptroffset: int,
            startsoffset: int,
            stopsoffset: int,
            tolength: int,
            fromlength: int,
            fromwidth: int,
        ):
            for k in range(tolength * (fromwidth + 1)):
                toptr[k] = -1
            for i in range(fromlength):
                start = fromstarts[startsoffset + i]
                stop = fromstops[stopsoffset + i]
                if (start != stop) and (stop > tolength):
                    raise ValueError("max(stop) > len(content)")
                j = start
                while j < stop:
                    if toptr[(j * (fromwidth + 1)) + fromwidth] != -1:
                        uniquecontents = false
                        return
                    for k in range(fromwidth):
                        toptr[(j * (fromwidth + 1)) + k] = fromptr[
                            (fromptroffset + (i * fromwidth)) + k
                        ]
                    toptr[(j * (fromwidth + 1)) + fromwidth] = int(j - start)
                    j = j + 1
            uniquecontents = true
            return


awkward_identities32_from_listarray32
----------------------------------------------------

def awkward_identities32_from_listarray32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromptroffset: int,
    startsoffset: int,
    stopsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listarray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        fromptroffset,
        startsoffset,
        stopsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities32_from_listarrayU32
----------------------------------------------------

def awkward_identities32_from_listarrayU32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromptroffset: int,
    startsoffset: int,
    stopsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listarray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        fromptroffset,
        startsoffset,
        stopsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities32_from_listarray64
----------------------------------------------------

def awkward_identities32_from_listarray64(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromptroffset: int,
    startsoffset: int,
    stopsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listarray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        fromptroffset,
        startsoffset,
        stopsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_listarray32
----------------------------------------------------

def awkward_identities64_from_listarray32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromptroffset: int,
    startsoffset: int,
    stopsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listarray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        fromptroffset,
        startsoffset,
        stopsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_listarrayU32
----------------------------------------------------

def awkward_identities64_from_listarrayU32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromptroffset: int,
    startsoffset: int,
    stopsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listarray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        fromptroffset,
        startsoffset,
        stopsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_listarray64
----------------------------------------------------

def awkward_identities64_from_listarray64(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromptroffset: int,
    startsoffset: int,
    stopsoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_listarray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        fromptroffset,
        startsoffset,
        stopsoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities_from_regulararray
----------------------------------------------------

for ID in int:

    def awkward_identities_from_regulararray(
        toptr: List[ID],
        fromptr: List[ID],
        fromptroffset: int,
        size: int,
        tolength: int,
        fromlength: int,
        fromwidth: int,
    ):
        for i in range(fromlength):
            for j in range(size):
                for k in range(fromwidth):
                    toptr[(((i * size) + j) * (fromwidth + 1)) + k] = fromptr[
                        (fromptroffset + (i * fromwidth)) + k
                    ]
                toptr[(((i * size) + j) * (fromwidth + 1)) + fromwidth] = int(j)
        k = ((fromlength + 1) * size) * (fromwidth + 1)
        while k < (tolength * (fromwidth + 1)):
            toptr[k] = -1
            k = k + 1
        return


awkward_identities32_from_regulararray
----------------------------------------------------

def awkward_identities32_from_regulararray(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    size: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_regulararray(
        toptr, fromptr, fromptroffset, size, tolength, fromlength, fromwidth
    )


awkward_identities64_from_regulararray
----------------------------------------------------

def awkward_identities64_from_regulararray(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    size: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_regulararray(
        toptr, fromptr, fromptroffset, size, tolength, fromlength, fromwidth
    )


awkward_identities_from_indexedarray
----------------------------------------------------

for ID in int:
    for T in int:

        def awkward_identities_from_indexedarray(
            uniquecontents: List[bool],
            toptr: List[ID],
            fromptr: List[ID],
            fromindex: List[T],
            fromptroffset: int,
            indexoffset: int,
            tolength: int,
            fromlength: int,
            fromwidth: int,
        ):
            for k in range(tolength * fromwidth):
                toptr[k] = -1
            for i in range(fromlength):
                j = fromindex[indexoffset + i]
                if j >= tolength:
                    raise ValueError("max(index) > len(content)")
                else:
                    if j >= 0:
                        if toptr[j * fromwidth] != -1:
                            uniquecontents = false
                            return
                        for k in range(fromwidth):
                            toptr[(j * fromwidth) + k] = fromptr[
                                (fromptroffset + (i * fromwidth)) + k
                            ]
            uniquecontents = true
            return


awkward_identities32_from_indexedarray32
----------------------------------------------------

def awkward_identities32_from_indexedarray32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromindex: List[int],
    fromptroffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_indexedarray(
        uniquecontents,
        toptr,
        fromptr,
        fromindex,
        fromptroffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities32_from_indexedarrayU32
----------------------------------------------------

def awkward_identities32_from_indexedarrayU32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromindex: List[int],
    fromptroffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_indexedarray(
        uniquecontents,
        toptr,
        fromptr,
        fromindex,
        fromptroffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities32_from_indexedarray64
----------------------------------------------------

def awkward_identities32_from_indexedarray64(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromindex: List[int],
    fromptroffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_indexedarray(
        uniquecontents,
        toptr,
        fromptr,
        fromindex,
        fromptroffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_indexedarray32
----------------------------------------------------

def awkward_identities64_from_indexedarray32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromindex: List[int],
    fromptroffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_indexedarray(
        uniquecontents,
        toptr,
        fromptr,
        fromindex,
        fromptroffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_indexedarrayU32
----------------------------------------------------

def awkward_identities64_from_indexedarrayU32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromindex: List[int],
    fromptroffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_indexedarray(
        uniquecontents,
        toptr,
        fromptr,
        fromindex,
        fromptroffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities64_from_indexedarray64
----------------------------------------------------

def awkward_identities64_from_indexedarray64(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromindex: List[int],
    fromptroffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
):
    return awkward_identities_from_indexedarray(
        uniquecontents,
        toptr,
        fromptr,
        fromindex,
        fromptroffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
    )


awkward_identities_from_unionarray
----------------------------------------------------

for ID in int:
    for T in int:
        for I in int:

            def awkward_identities_from_unionarray(
                uniquecontents: List[bool],
                toptr: List[ID],
                fromptr: List[ID],
                fromtags: List[T],
                fromindex: List[I],
                fromptroffset: int,
                tagsoffset: int,
                indexoffset: int,
                tolength: int,
                fromlength: int,
                fromwidth: int,
                which: int,
            ):
                for k in range(tolength * fromwidth):
                    toptr[k] = -1
                for i in range(fromlength):
                    if fromtags[tagsoffset + i] == which:
                        j = fromindex[indexoffset + i]
                        if j >= tolength:
                            raise ValueError("max(index) > len(content)")
                        else:
                            if j < 0:
                                raise ValueError("min(index) < 0")
                            else:
                                if toptr[j * fromwidth] != -1:
                                    uniquecontents = false
                                    return
                                for k in range(fromwidth):
                                    toptr[(j * fromwidth) + k] = fromptr[
                                        (fromptroffset + (i * fromwidth)) + k
                                    ]
                uniquecontents = true
                return


awkward_identities32_from_unionarray8_32
----------------------------------------------------

def awkward_identities32_from_unionarray8_32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromtags: List[int],
    fromindex: List[int],
    fromptroffset: int,
    tagsoffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
    which: int,
):
    return awkward_identities_from_unionarray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        fromptroffset,
        tagsoffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
        which,
    )


awkward_identities32_from_unionarray8_U32
----------------------------------------------------

def awkward_identities32_from_unionarray8_U32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromtags: List[int],
    fromindex: List[int],
    fromptroffset: int,
    tagsoffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
    which: int,
):
    return awkward_identities_from_unionarray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        fromptroffset,
        tagsoffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
        which,
    )


awkward_identities32_from_unionarray8_64
----------------------------------------------------

def awkward_identities32_from_unionarray8_64(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromtags: List[int],
    fromindex: List[int],
    fromptroffset: int,
    tagsoffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
    which: int,
):
    return awkward_identities_from_unionarray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        fromptroffset,
        tagsoffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
        which,
    )


awkward_identities64_from_unionarray8_32
----------------------------------------------------

def awkward_identities64_from_unionarray8_32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromtags: List[int],
    fromindex: List[int],
    fromptroffset: int,
    tagsoffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
    which: int,
):
    return awkward_identities_from_unionarray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        fromptroffset,
        tagsoffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
        which,
    )


awkward_identities64_from_unionarray8_U32
----------------------------------------------------

def awkward_identities64_from_unionarray8_U32(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromtags: List[int],
    fromindex: List[int],
    fromptroffset: int,
    tagsoffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
    which: int,
):
    return awkward_identities_from_unionarray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        fromptroffset,
        tagsoffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
        which,
    )


awkward_identities64_from_unionarray8_64
----------------------------------------------------

def awkward_identities64_from_unionarray8_64(
    uniquecontents: List[bool],
    toptr: List[int],
    fromptr: List[int],
    fromtags: List[int],
    fromindex: List[int],
    fromptroffset: int,
    tagsoffset: int,
    indexoffset: int,
    tolength: int,
    fromlength: int,
    fromwidth: int,
    which: int,
):
    return awkward_identities_from_unionarray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        fromptroffset,
        tagsoffset,
        indexoffset,
        tolength,
        fromlength,
        fromwidth,
        which,
    )


awkward_identities_extend
----------------------------------------------------

for ID in int:

    def awkward_identities_extend(
        toptr: List[ID],
        fromptr: List[ID],
        fromoffset: int,
        fromlength: int,
        tolength: int,
    ):
        i = 0
        while i < fromlength:
            toptr[i] = fromptr[fromoffset + i]
            i = i + 1
        while i < tolength:
            toptr[i] = -1
            i = i + 1
        return


awkward_identities32_extend
----------------------------------------------------

def awkward_identities32_extend(
    toptr: List[int],
    fromptr: List[int],
    fromoffset: int,
    fromlength: int,
    tolength: int,
):
    return awkward_identities_extend(toptr, fromptr, fromoffset, fromlength, tolength)


awkward_identities64_extend
----------------------------------------------------

def awkward_identities64_extend(
    toptr: List[int],
    fromptr: List[int],
    fromoffset: int,
    fromlength: int,
    tolength: int,
):
    return awkward_identities_extend(toptr, fromptr, fromoffset, fromlength, tolength)