Base namespace for container creation and elementwise access of data

Efficient functions for operating in index space. Take-off of the argsort, argmin, etc. type functions from Matlab. These functions generally only work on readers and all return some version of an index or list of indexes.

Functions for working with RoaringBitmaps. These are integrated deeply into several tech.v3.datatype algorithms and have many potential applications in high performance computing applications as they are both extremely fast and storage-space efficient.

Namespace for implementing various basic convolutions. Currently only 1d convolutions are supported.

Thorough bindings to java.time.datetime. Includes packed datatypes and lifting various datetime datatypes into the datatype system.

Generic, basic error handling. No dependencies aside from apache commons math for NAN exception.

Generalized C Foreign Function Interface (FFI) that unifies JNA and JDK-16 FFI architectures.

General utilites to work with clang in order to define things like structs or enumerations.

Graalvm-specific namespace that implements the dtype-next ffi system and allows users to build stand-alone shared libraries that other languages can use to call Clojure code via a binary C interface.

Arithmetic and statistical operations based on the Buffer interface. These operators and functions all implement vectorized interfaces so passing in something convertible to a reader will return a reader. Arithmetic operations are done lazily. These functions generally incur a large dispatch cost so for example each call to '+' checks all the arguments to decide if it should dispatch to an iterable implementation or to a reader implementation. For tight loops or operations like map and filter, using the specific operators will result in far faster code than using the '+' function itself.

Calculate the numeric gradient of successive elements. Contains simplified versions of numpy.gradient and numpy.diff.

Provides the ability to efficiently write binary data to a file with an automatic conversion to a native-buffer using mmap.

Support for malloc/free and generalized support for reading/writing typed data to a long integer address of memory.

Nippy bindings for datatype base types and tensor types

Implements the 'packed/unpacked' concept in datatype. This allows us to take objects like LocalDate's and store them in int32 storage which dramatically decreases their size.

High performance reductions based on tech.v3.datatype concepts as well as java stream concepts.

Implementation of reservoir sampling designed to be used in other systems. Provides a low-level sampler object and a double-reservoir that implements DoubleConsumer and derefs to a buffer of doubles.

Nan-aware, high quality and reasonably efficient summation and descriptive statistics.

Structs are datatypes composed of primitive datatypes or other structs. Similar to records except they do not support string or object columns, only numeric values. They have memset-0 initialization, memcpy copy semantics. For correct equals, hashing, convert struct into a normal persistent map via into.

Implementation of the scipy continuous wavelet transform. See fastmath for implementations of the discrete wavelet transform.

Bindings to buffered images for the datatype system

Serial and parallel iteration strategies across iterators and index spaces.

Read an iterator from in a separate thread into a queue returning a new iterator. This allows a traversal of potentially blocking information to happen in a separate thread with a fixed queue size.

ND bindings for the tech.v3.datatype system. A Tensor is conceptually just a tuple of a buffer and an index operator that is capable of converting indexes in ND space into a single long index into the buffer. Tensors implement the tech.v3.datatype.NDBuffer interface and outside this file ND objects are expected to simply implement that interface.

Implement a mapping from double->color for each entry in a tensor. Produces an image of the same dimensions in pixels as the input tensor.

Dimensions implement a projection from ND space in the the address space of the buffer along with a reverse projection from the address space back into ND space.