►Nawkward | |
►Nkernel | |
Carray_deleter | Used as a std::shared_ptr deleter (second argument) to overload delete ptr with delete[] ptr |
Ccuda_array_deleter | Used as a std::shared_ptr deleter (second argument) to overload delete ptr with cudaFree |
CLibraryCallback | |
CLibraryPathCallback | |
Cno_deleter | Used as a std::shared_ptr deleter (second argument) to overload delete ptr with nothing (no dereferencing) |
►NLayoutBuilder | |
CBitMasked | Builds a BitMaskedArray in which mask values are packed into a bitmap |
CByteMasked | Builds a ByteMaskedArray using a mask which is an array of booleans that determines whether the corresponding value in the contents array is valid or not |
CEmpty | Builds an EmptyArray which has no content in it. It is used whenever an array's type is not known because it is empty |
CEmptyRecord | Builds an Empty RecordArray which has has zero contents. It still represents a non-empty array. In this case, its length is specified by length |
CField | Helper class for sending a pair of field names (as enum) and field type as template parameters in Record |
CIndexed | Builds an IndexedArray which consists of an index buffer. It is a general-purpose tool for changing the order of and/or duplicating some content |
CIndexedOption | Builds an IndexedOptionArray which consists of an index buffer. The negative values in the index are interpreted as missing |
CList | Builds a ListArray which generalizes ListOffsetArray. Instead of a single offsets array, ListArray has - starts which is the starting index of each list and stops which is the stopping index of each list |
CListOffset | Builds a ListOffsetArray which describes unequal-length lists (often called a "jagged" or "ragged" array). The underlying data for all lists are in a BUILDER content. It is subdivided into lists according to an offsets array, which specifies the starting and stopping index of each list |
CNumpy | Builds a NumpyArray which describes multi-dimensional data of PRIMITIVE type |
CRecord | Builds a RecordArray which represents an array of records, which can be of same or different types. Its contents is an ordered list of arrays with the same length as the length of its shortest content; all are aligned element-by-element, associating a field name to every content |
CRegular | Builds a RegularArray that describes lists that have the same length, a single integer size. Its underlying content is a flattened view of the data; that is, each list is not stored separately in memory, but is inferred as a subinterval of the underlying data |
CTuple | Builds a RecordArray which represents an array of tuples which can be of same or different types without field names, indexed only by their order |
CUnion | Builds a UnionArray which represents data drawn from an ordered list of contents, which can have different types, using tags, which is an array of integers indicating which content each array element draws from and index, which is an array of integers indicating which element from the content to draw from |
CUnmasked | Builds an UnmaskedArray which the values are never, in fact, missing. It exists to satisfy systems that formally require this high-level type without the overhead of generating an array of all True or all False values |
►Nutil | |
CNameValuePair | |
CArrayBuilder | User interface to the Builder system: the ArrayBuilder is a fixed reference while the Builder subclass instances change in response to accumulating data |
CArrayCache | Abstract superclass of cache for VirtualArray, defining the interface |
CArrayGenerator | Abstract superclass to generate arrays for VirtualArray, defining the interface |
CArrayType | Describes the high level type of a user-facing array, i.e. ak.Array in Python, as opposed to Content. The length of the array is part of its type |
CBitMaskedArray | Represents potentially missing data by overlaying a bit mask over its content |
CBitMaskedArrayBuilder | BitMaskedArray builder from a Bit Masked JSON Form |
CBitMaskedForm | Form describing BitMaskedArray |
CBoolBuilder | Builder node that accumulates boolean values |
CBuffersContainer | Abstract class to represent the output of ak.to_buffers. In Python, this would be a dict of NumPy arrays |
CBuilder | Abstract base class for nodes within an ArrayBuilder that cumulatively discover an array's type and fill it |
CByteMaskedArray | Represents potentially missing data by overlaying a byte mask over its content |
CByteMaskedArrayBuilder | |
CByteMaskedForm | Form describing ByteMaskedArray |
CComplex128Builder | Builder node that accumulates real numbers (double ) |
CContent | Abstract superclass of all array node types (flat hierarchy). Any Content can be nested within any other Content |
CCppBuffers | |
CDatetimeBuilder | Builder node that accumulates integers (int64_t ) |
CEmptyArray | Represents an array with length zero and (perhaps as a consequence) UnknownType |
CEmptyArrayBuilder | |
CEmptyForm | Form describing EmptyArray |
CFileLikeObject | Abstract class to represent a file-like object, something with a read(num_bytes) method. Satisfies RapidJSON's Stream interface |
CFloat64Builder | Builder node that accumulates real numbers (double ) |
CForm | Abstract superclass of all array node forms, which expresses the nesting structure without any large Index or data buffers |
CFormBuilder | Abstract base class for nodes within a LayoutBuilder Every builder will have an output buffer based on the key_format="part{partition}-{form_key}-{attribute}" |
CForthInputBuffer | HERE |
CForthMachineOf | |
CForthOutputBuffer | HERE |
CForthOutputBufferOf | |
CFromJsonObjectSchema | |
CGrowableBuffer | Discontiguous, one-dimensional buffer (which consists of multiple contiguous, one-dimensional panels) that can grow indefinitely by calling append |
CIdentities | A contiguous, two-dimensional array of integers and a list of strings used to represent a path from the root of an array structure to each item in an array |
CIdentitiesOf | A contiguous, two-dimensional array of integers and a list of strings used to represent a path from the root of an array structure to each item in an array |
CIndex | A contiguous, one-dimensional array of integers used to represent data structures, rather than numerical data in the arrays themselves |
CIndexedArrayBuilder | |
CIndexedArrayOf | Filters, rearranges, and/or duplicates items in its content through an index, which has the same effect as lazily-applied carry |
CIndexedForm | Form describing IndexedArray (with OPTION = false ) |
CIndexedOptionArrayBuilder | |
CIndexedOptionForm | Form describing IndexedOptionArray |
CIndexOf | A contiguous, one-dimensional array of integers used to represent data structures, rather than numerical data in the arrays themselves |
CInt64Builder | Builder node that accumulates integers (int64_t ) |
CIrregularlyPartitionedArray | PartitionedArray of arbitrary length partitions |
Cis_specialization | |
Cis_specialization< Ref< Args... >, Ref > | |
CIterator | Represents the current state of iteration over a Content array |
CLayoutBuilder | User interface to the FormBuilder system: the LayoutBuilder is a fixed reference while the FormBuilder subclass instances change in response to accumulating data |
CListArrayBuilder | |
CListArrayOf | Represents an array of nested lists that can have different lengths using two indexes named starts and stops |
CListBuilder | Builder node that accumulates lists |
CListForm | Form describing ListArray |
CListOffsetArrayBuilder | |
CListOffsetArrayOf | Represents an array of nested lists that can have different lengths using one index named offsets |
CListOffsetForm | Form describing ListOffsetArray |
CListType | Describes the high level type of lists of variable length, as opposed to RegularType |
CNone | Represents a scalar missing value, which is None in Python |
CNumpyArray | Represents a rectilinear numerical array that can be converted to and from NumPy without loss of information or copying the underlying buffer |
CNumpyArrayBuilder | |
CNumpyForm | Form describing NumpyArray |
COptionBuilder | Builder node that accumulates data with missing values (None ) |
COptions | Container for all configuration options needed by ArrayBuilder, GrowableBuffer, LayoutBuilder and the Builder subclasses |
COptionType | Describes the high level type of data with possible missing values, represented by None in python |
CPanel | |
CPartitionedArray | Abstract superclass of all PartitionedArray node types. PartitionedArrays contain a list of Content, but Content cannot contain PartitionedArrays |
CPrimitiveType | Describes the high level type of an array that contains fixed-size items, such as numbers or booleans |
CRecord | Represents a tuple or record, a scalar value from RecordArray |
CRecordArray | Represents an array of tuples or records, in which a tuple has a fixed number of differently typed fields and a record has a named set of differently typed fields |
CRecordArrayBuilder | |
CRecordBuilder | Builder node for accumulated records |
CRecordForm | Form describing RecordArray (not a Record) |
CRecordType | Describes the high level type of data containing tuples or records |
CReducer | Abstract class for all reducer algorithms |
CReducerAll | Reducer algorithm that returns true if all values are true , false otherwise. The identity is true |
CReducerAny | Reducer algorithm that returns true if any values are true , false otherwise. The identity is false |
CReducerArgmax | Reducer algorithm that returns the position of the maximum value. The identity is meaningless and should be covered using mask = true |
CReducerArgmin | Reducer algorithm that returns the position of the minimum value. The identity is meaningless and should be covered using mask = true |
CReducerCount | Reducer algorithm that simply counts items. The identity is 0 |
CReducerCountNonzero | Reducer algorithm that counts non-zero items. The identity is 0 |
CReducerMax | Reducer algorithm that returns the maximum value. The identity is minus infinity or the smallest possible value |
CReducerMin | Reducer algorithm that returns the minimum value. The identity is infinity or the largest possible value |
CReducerProd | Reducer algorithm that multiplies items. The identity is 1 |
CReducerSum | Reducer algorithm that adds up items. The identity is 0 |
CRegularArray | Represents an array of nested lists that all have the same length using a scalar size, rather than an index |
CRegularArrayBuilder | |
CRegularForm | Form describing RegularArray |
CRegularType | Describes the high level type of lists of a given length, as opposed to ListType |
CSlice | A sequence of SliceItem objects representing a tuple passed to Python's __getitem__ |
CSliceArrayOf | Represents an array of integers in a slice (possibly converted from an array of booleans) |
CSliceAt | Represents an integer in a tuple of slices passed to __getitem__ in Python |
CSliceEllipsis | Represents a Python Ellipsis object (usual syntax: array[...] ) |
CSliceField | Represents a single string in a slice tuple, indicating that a RecordArray should be replaced by one of its fields |
CSliceFields | |
CSliceGenerator | Generator for lazy slicing. Used to avoid materializing a VirtualArray before its content is needed (in case its content is never needed) |
CSliceItem | Abstract class for slice items, which are elements of a tuple passed to an array's __getitem__ in Python |
CSliceJaggedOf | Represents an array of nested lists, where the content may be SliceArrayOf, SliceMissingOf, or SliceJaggedOf (no equivalent in NumPy) |
CSliceMissingOf | Represents a SliceArrayOf, SliceMissingOf, or SliceJaggedOf with missing values: None (no equivalent in NumPy) |
CSliceNewAxis | Represents NumPy's newaxis marker (a.k.a. None ), which prompts __getitem__ to insert a length-1 regular dimension (RegularArray) at some point in the slice tuple |
CSliceRange | Represents a Python slice object (usual syntax: array[start:stop:step] ) |
CStringBuilder | Builder node that accumulates strings |
CToJson | |
CToJsonFile | Produces a JSON-formatted file |
CToJsonPrettyFile | Produces a pretty JSON-formatted file |
CToJsonPrettyString | Produces a pretty JSON-formatted string |
CToJsonString | Produces a JSON-formatted string |
CTupleBuilder | Builder node for accumulated tuples |
CType | Abstract superclass of all high level types (flat hierarchy) |
CUnionArrayBuilder | |
CUnionArrayOf | Represents heterogeneous data by interleaving several contents, indicating which is relevant at a given position with tags and where to find each item in the contents with an interleaved index |
CUnionBuilder | Builder node for accumulated heterogeneous data |
CUnionForm | Form describing UnionArray |
CUnionType | Describes the high level type of heterogeneous data |
CUnknownBuilder | Builder node for accumulated data whose type is not yet known |
CUnknownType | Describes the high level type of data with whose type is not known, usually because an ArrayBuilder did not have any instances to sample |
CUnmaskedArray | Converts content of any type into an OptionType in which all values happen to be valid |
CUnmaskedArrayBuilder | |
CUnmaskedForm | Form describing UnmaskedArray |
CVirtualArray | Represents an array that can be generated on demand |
CVirtualForm | Form describing VirtualArray |
Cvisit_impl | Class to index tuple at runtime |
Cvisit_impl< 0 > | INDEX reached 0 , which means the runtime index did not exist in the tuple |
Cvoider | |
CError | |
CForthMachine | HERE |
CPersistentSharedPtr | Array nodes are frequently copied, but for some applications (one in Numba) it's better to keep a persistent std::shared_ptr |
CPyArrayCache | |
CPyArrayGenerator | |
Cpyobject_deleter | Used as a std::shared_ptr deleter (second argument) to overload delete ptr with Py_DECREF(ptr) |
CStartupLibraryPathCallback | |