Symbolic arrays

Symbolic array-valued expressions (symbolic arrays) are supported by Symbolics. Symbolic array expressions propagate useful metadata that depends on input arrays: array dimension, element type and shape.

You can create a symbolic array variable with the following syntax:

@variables A[1:5, 1:3] b[1:3]

Here A is a symbolic matrix of size (5, 3) and b is a symbolic vector of length 3.

julia> size(A)
(5, 3)

julia> size(b)
(3,)

julia> ndims(A)
2

julia> ndims(b)
1

julia> eltype(A)
Real

julia> eltype(b)
Real

Array operations

Operations on symbolic arrays return symbolic array expressions:

julia> c = A * b
(A*b)[1:5]

julia> size(c)
(5,)

julia> eltype(c)
Real

Adjoints, matrix-matrix, and matrix-vector multiplications are supported. Dot product returns a scalar-valued expression:

julia> b'b
adjoint(b)*b

julia> size(b'b)
()

Outer product returns a matrix:

julia> b * b'
(b*adjoint(b))[1:3,1:3]

julia> size(b*b')
(3, 3)

Broadcast, map and reduce

julia> A .* b'
(broadcast(*, A, adjoint(b))[1:5,1:3]

julia> map(asin, (A*b))
(map(asin, A*b))[1:5]

julia> sum(A)
...

julia> typeof(sum(A))
Num # it's a scalar!

julia> typeof(sum(A, dims=2))
Arr{Real, 2} # it's a vector

Indexing and delayed computation

Indexing array expressions is fairly flexible in Symbolics. Let's go through all the possible ways to index arrays.

Scalar indexing and scalarization

julia> AAt = A*A'
(A*adjoint(A))[1:5,1:5]

julia> AAt[2,3]
(A*adjoint(A))[2,3]

Here we indexed for the element (2,3), but we got back a symbolic indexing expression. You may want to force the element to be computed in terms of the elements of A. This can be done, using scalarize function.

julia> Symbolics.scalarize(AAt[2,3])
A[2, 1]*A[3, 1] + A[2, 2]*A[3, 2] + A[2, 3]*A[3, 3]

julia> @syms i::Int j::Int
(i, j)

julia> Symbolics.scalarize(AAt[i,j])
A[i, 1]*A[j, 1] + A[i, 2]*A[j, 2] + A[i, 3]*A[j, 3]

In general any scalar expression which is derived from array expressions can be scalarized.

julia> sum(A[:,1]) + sum(A[2,:])
Symbolics._mapreduce(identity, +, A[Colon(), 1], Colon(), (:init => false,)) + Symbolics._mapreduce(identity, +, A[2, Colon()], Colon(), (:init => false,))

julia> Symbolics.scalarize(sum(A[:,1]) + sum(A[2,:]))
A[1, 1] + A[2, 2] + A[2, 3] + A[4, 1] + A[5, 1] + 2A[2, 1] + A[3, 1]