tech.datatype — techascent/tech.datatype 3.5

Generalized efficient manipulations of sequences of primitive datatype. Includes specializations for java arrays and nio buffers. There are specializations to allow implementations to provide efficient full typed copy functions when the types can be ascertained. Usually this involves a double-dispatch on both the src and dest arguments:

https://en.wikipedia.org/wiki/Double_dispatch.

Generic operations include:

1. datatype of this sequence.
2. Writing to, reading from.
3. Construction.
4. Efficient mutable copy from one sequence to another.

->array clj

(->array item)

Returns nil of item does not share a backing store with an array.

->array-copy clj

(->array-copy item)

Copy the data into an array that can correctly hold the datatype. This array may not have the same datatype as the source item

->buffer-backing-store clj

(->buffer-backing-store src-ary)

Convert to nio buffer that stores the data for the object. This may have a different datatype than the object, so for instance the backing store for the uint8 datatype is a nio buffer of type int8.

->typed-buffer clj

(->typed-buffer item & {:keys [datatype]})

Conversion of a thing to a typed buffer

->vector clj

(->vector item)

Conversion to persistent vector

add-cast-fn clj

(add-cast-fn datatype cast-fn)

add-container-conversion-fn clj

(add-container-conversion-fn src-container-type dst-container-type convert-fn)

Add a container->container conversion. Function takes a dst-datatype and the src-container and returns a tuple of [result-container result-offset].

add-copy-operation clj

(add-copy-operation src-container-type
                    dst-container-type
                    src-dtype
                    dst-dtype
                    unchecked?
                    copy-fn)

Add a new copy operation. Note that this is a single point in a 5 dimensional space of operations.

add-datatype->size-mapping clj

(add-datatype->size-mapping datatype byte-size)

add-unchecked-cast-fn clj

(add-unchecked-cast-fn datatype cast-fn)

cast clj

(cast value datatype)

clone clj

(clone item & {:keys [datatype]})

container-type clj

(container-type item)

copy! clj

(copy! src dst)

(copy! src src-offset dst dst-offset n-elems)

(copy! src src-offset dst dst-offset n-elems options)

copy-raw->item! clj

(copy-raw->item! raw-data ary-target target-offset)

(copy-raw->item! raw-data ary-target target-offset options)

Copy raw data into an array. Returns a tuple of [ary-target result-offset-after-copy]

datatype->byte-size clj

(datatype->byte-size datatype)

ecount clj

(ecount item)

Type hinted ecount so numeric expressions run faster. Calls clojure.core.matrix/ecount.

from-prototype clj

(from-prototype item & {:keys [datatype shape]})

get-datatype clj

(get-datatype item)

get-value clj

(get-value item offset)

make-array-of-type clj

(make-array-of-type datatype elem-count-or-seq & [options])

make-buffer-of-type clj

(make-buffer-of-type datatype elem-count-or-seq & [options])

make-typed-buffer clj

(make-typed-buffer datatype elem-count-or-seq & [options])

Support for unsigned datatypes comes via the typed buffer mechanism

set-constant! clj

(set-constant! item offset value elem-count)

set-value! clj

(set-value! item offset value)

shape clj

(shape item)

m/shape with fallback to m/ecount if m/shape is not available.

shape->ecount clj

(shape->ecount shape-or-num)

unchecked-cast clj

(unchecked-cast value datatype)