Create a new dense julia array that is the 'transpose' of the input tensor. Transposing ensures the memory alignment matches as Julia is column-major while datatype is row-major.

Create a new Julia tuple type from a sequence of types.

Create a new Julia type from an existing type and a sequence of other types.

Resolves to the base julia array datatype

Call a function. The result will be marshalled back to the jvm and if necessary, rooted. This method is normally not necessary but useful if you would like to use keywords in your argument list or specify to avoid rooting the result.

Call a julia function and pass in keyword arguments. This is useful if you would like to specify the arglist and kw-argmap. Normally this is done for you.

Call periodically to release rooted Julia objects. We root return values if they aren't primitives and then hook them to the jvm GC such that they get put in a queue once they aren't reachable by the program. This call clears that queue and unroots them thus notifying the Julia GC that they aren't reachable any more.

In the future point this may be done for you.

Initialize julia optionally providing an explicit path which will override the julia library search mechanism.

Currently the search mechanism is:

user-path->JULIA_HOME->"julia"

Returns :ok on success else exception.

Options:

• :julia-home - Explicitly declare the env var julia-home.
• :n-threads - Set to -1 to set to n-cpus. Defaults to nil which means single threaded unless the JULIA_NUM_THREADS environment variable is set. Note that this has implications for application stability - see the signals.md topic.
• :signals-enabled? - Users do not usually need to set this. This allows users to disable all of Julia's signal handling most likely leading to a crash. See the signals.md topic.

Eval a string in julia returning the result. If the result is callable in Julia, the result will be callable in Clojure.

Resolves to the julia undef type

Create a julia named tuple from a map of values. The keys of the map must be keywords or symbols. A new named tuple type will be created and instantiated.

Create a new, uninitialized dense julia array. Because Julia is column major while tech.v3.datatype is row major, the returned array's size will be the reverse of dtype/shape as that keeps the same in memory alignment of data.

Set the log level to use when rooting/unrooting julia objects. We automatically root julia objects in a julia id dictionary that we expose to JVM objects. This code isn't yet perfect, so sometimes it is worthwhile to log all root/unroot operations.

Valid log levels are valid log levels for clojure/tools.logging.

Instantiate a Julia struct type (tuple, NamedTuple, etc). Use this after apply-tuple-type in order to create an instance of your new type.

Create a julia tuple from a set of arguments. The tuple type will be the same datatype as the argument types.

This function converts the arguments to julia, calls apply-tuple-type on the resulting argument types, and then instantiates an instance of the given newly created tuple type.

Get the julia type of an item.

Run code in which all objects created within this context will be released once the stack unwinds where released means unrooted and thus potentially available to the next julia garbage collection run.