Create a reduce node.

• comm-reducer - A commutative reducer produced via either commutative-reducer or tvm-fn->commutative-reducer.
• reduce-axis - A list of either maps of {:domain :name} or iteration-variable’s of type :communicative-reduce. If a list element is a map?, it will be interpreted as a map of {:domain :name} in the corresponding iteration variable will be created for you.

• read-exprs - Either fn?’s or a list of expressions that must equal the number of inputs to commutative-reducer and that must be based off of the variables defined in reduce-axis. If read-exprs are clojure ’fn?’s they will be called with the reduction variables created from reduce-axis.

Create a commutative reducer. Reducers are used in as the part of the commutative reduction pathway.

• reduce-fn-args - sequence of maps of {:name :datatype :argument-type :identity-value} tell you the name of the argument, the datatype, and when the argument is and :accumulating arg or an :incoming arg. If the argument is an accumulator argument then an :identity-value must be provided.
• incoming-names - Argument names of the incoming values.
• reduction-ast-fn - fn taking ‘(+ (count accum-args) (count incoming-args))’ arguments and returning an AST that performs the reduction.

Returns a commutative reducer you can use in Reduce.

Compute a new tensor over this shape.

Construct a new tensor by computing over the shape domain.

The compute rule is result[axis] = fcompute(axis)

Parameters

shape: Array of Expr The shape of the tensor

fcompute: lambda function of indices-> value Specifies the input source expression

name: str, optional The name hint of the tensor

tag: str, optional Additonal tag information about the compute.

attrs: dict, optional The additional auxiliary attributes about the compute.

Returns

The created compute node

Create a variable that controls iteration through the data. The iteration type affects the class of optimizations that the compiler is able to apply to the affected expressions,

Parameters
----------
dom : Range
    The domain of iteration.

name : str
    The name of iteration variable.

iteration-type : keyword
    The type of iteration.

thread-tag : str
    The thread tag of the iteration variable.

Create a thread iter-var from a thread axis name

Create a user-supplied tensor variable

Create a recursive scan operation

Get an item from a tensor

Like (fn) but retains the arglists. Lambda in clojure unfortunately does not.

Get the vector of tvm-safe string argument names to a tvm function.

Make a reducer out of a tvm function assuming all arguments are the same datatype.

Accumulation arguments are considered the first N arguments where N is the number of initial values. The rest of the arguments are considered incoming arguments. There must be at least one each of accumulation and incoming arguments.

• tvm-fn - a function with proper metadata such that :arglists can be found.
• identity-values - list of identity values. This implicitly indicates the number of accumulation arguments as there must be one identity value per accumulation arguments.
• datatype - Option datatype. If not provided will be inferred from the datatypes of identity-values.

Lets in tvm must be nested. This leads to an exciting macro. Pairs must be of the form var val-expr. Body is not an implicit do!!

Create a scalar variable. Returns a node handle