Implementation

verifytensorexpr(ex)

Check that ex is a valid tensor expression and throw an ArgumentError if not. Valid tensor expressions satisfy one of the following (recursive) rules):

• The expression is a scalar expression or a tensor expression.
• The expression is an assignment or a definition, and the left hand side and right hand side are valid tensor expressions or scalars.
• The expression is a block, and all subexpressions are valid tensor expressions or scalars.

See also istensorexpr and isscalarexpr.

isassignment(ex)

Test if ex is an assignment expression, i.e. ex is of one of the forms:

a = b
a += b
a -= b

isdefinition(ex)

Test if ex is a definition expression, i.e. ex is of the form:

a := b
a ≔ b

isindex(ex)

Test for a valid index, namely a symbol or integer, or an expression of the form i′ where i is itself a valid index.

istensor(ex)

Test for a simple tensor object indexed by valid indices. This means an expression of the form:

A[i, j, k, ...]
A[i j k ...]
A[i j k ...; l m ...]
A[(i, j, k, ...); (l, m, ...)]

where i, j, k, ... are valid indices.

istensorexpr(ex)

Test for a tensor expression. This means an expression which can be evaluated to a valid tensor. This includes:

A[...] + B[...] - C[...] - ...
A[...] * B[...] * ...
λ * A[...] / μ
λ \ conj(A[...])
A[...]' + adjoint(B[...]) - ...

isscalarexpr(ex)

Test for a scalar expression, i.e. an expression that can be evaluated to a scalar.

normalizeindices(ex::Expr)

Normalize indices of an expression by replacing all indices with a prime expression i' by indices with a unicode prime 'i′'.

expandconj(ex)

Expand all conj calls in an expression to conjugate the individual terms and factors.

nconindexcompletion(ex)

Complete the indices of the left hand side of an ncon expression. For example, the following expressions are equivalent after index completion.

@tensor A[:] := B[-1, 1, 2] * C[1, 2, -3]
@tensor A[-1, -2] := B[-1, 1, 2] * C[1, 2, -3]

extracttensorobjects(ex)

Extract all tensor objects which are not simple symbols with newly generated symbols, and assign them before the expression and after the expression as necessary, in order to avoid multiple evaluations of the expression constituting the tensor object.

insertcontractionchecks(ex)

Insert runtime checks before each contraction, which provide clearer debug information.

processcontractions(ex, treebuilder, treesorter, costcheck)

Process the contractions in ex using the given treebuilder and treesorter functions. This is done by first extracting a network representation from the expression, then building and sorting the contraction trees with a given treebuilder and treesorter function, and finally inserting the contraction trees back into the expression. When the costcheck argument equals :warn or :cache (as opposed to :nothing), the optimal contraction order is computed at runtime using the actual values of tensorcost and this optimal order is compared to the contraction order that was determined at compile time. If the compile time order deviated from the optimal order, a warning will be printed (in case of costcheck == :warn) or this particular contraction will be recorded in TensorOperations.costcache (in case of costcheck == :cache). Both the warning or the recorded cache entry contain a order suggestion that can be passed to the @tensor macro in order to encode the optimal contraction order at compile time..

tensorify(ex)

Main parsing step to transform a tensor expression ex into a series of function calls associated with the primitive building blocks (tensor operations and allocations).

_flatten(ex)

Flatten nested structure of an expression, returning an unnested Expr(:block, …).

removelinenumbernode(ex)

Remove all LineNumberNodes from an expression.

addtensoroperations(ex)

Fix references to TensorOperations functions in namespaces where @tensor is present but the functions are not.

insertbackend(ex, backend, operations)

Insert a backend into a tensor operation, e.g. for any op ∈ operations, transform TensorOperations.op(args...) -> TensorOperations.op(args..., Backend{:backend}())