14.2.11 Class Expr

mosek.fusion.Expr

It represents an expression of the form \(Ax+b\), where \(A\) is a matrix on sparse form, \(x\) is a variable vector and \(b\) is a vector of scalars.

Additionally, the class defines a set of static methods for constructing and manipulating various expressions.

Members:
 

Expr.eval – Evaluate the expression info to a simple array-based form.

Expr.getModel – Return the model to which the expression belongs

Expr.getShape – Return the shape of the expression

Expr.index – Return a specific term of the expression.

Expr.numNonzeros – Return the number of non-zero elements in the expression.

Expr.pick – Pick elements from this expression.

Expr.shape – Get the shape of the expression.

Expr.size – Return the expression size.

Expr.slice – Return a slice of the expression.

Expr.toString – Create a human readable string representation of the expression.

Expr.transpose – Transpose the expression.

Static members:
 

Expr.add – Compute the sum of expressions.

Expr.constTerm – Create an expression consisting of a constant vector of values.

Expr.dot – Return a scalar expression object representing the dot-product of two items.

Expr.flatten – Reshape the expression into a vector.

Expr.hstack – Stack a list of expressions horizontally (i.e. along the second dimension).

Expr.mul – Multiply two items.

Expr.mulDiag – Compute the diagonal of the product of two matrices.

Expr.mulElm – Element-wise product of two items.

Expr.neg – Change the sign of an expression

Expr.ones – Create a vector of ones as an expression.

Expr.outer – Return the outer-product of two vectors.

Expr.repeat – Repeat an expression a number of times in the given dimension.

Expr.reshape – Reshape the expression into a different shape with the same number of elements.

Expr.stack – Stack a list of expressions in an arbitrary dimension.

Expr.sub – Compute the difference of two expressions.

Expr.sum – Sum the elements of an expression.

Expr.vstack – Stack a list of expressions vertically (i.e. along the first dimension).

Expr.zeros – Create a vector of zeros as an expression.

Expr.add
Expr.add(Expression e1, Expression e2) -> Expression
Expr.add(Expression e1, Variable v2) -> Expression
Expr.add(Variable v1, Expression e2) -> Expression
Expr.add(Expression e1, float[] a1) -> Expression
Expr.add(Expression e1, float[][] a2) -> Expression
Expr.add(float[] a1, Expression e2) -> Expression
Expr.add(float[][] a2, Expression e2) -> Expression
Expr.add(Expression e1, float c) -> Expression
Expr.add(float c, Expression e2) -> Expression
Expr.add(Expression e1, Matrix m) -> Expression
Expr.add(Matrix m, Expression e2) -> Expression
Expr.add(Expression e1, NDSparseArray n) -> Expression
Expr.add(NDSparseArray n, Expression e2) -> Expression
Expr.add(Variable v1, Variable v2) -> Expression
Expr.add(Variable v1, float[] a1) -> Expression
Expr.add(Variable v1, float[][] a2) -> Expression
Expr.add(float[] a1, Variable v2) -> Expression
Expr.add(float[][] a2, Variable v2) -> Expression
Expr.add(Variable v1, float c) -> Expression
Expr.add(float c, Variable v2) -> Expression
Expr.add(Variable v1, Matrix m) -> Expression
Expr.add(Matrix m, Variable v2) -> Expression
Expr.add(Variable v1, NDSparseArray n) -> Expression
Expr.add(NDSparseArray n, Variable v2) -> Expression
Expr.add(Variable[] vs) -> Expression
Expr.add(Expression[] exps) -> Expression

Computes the sum of two or more expressions or variables. The following types of arguments are allowed:

A B
Variable Variable
Expression Expression
double  
double[]  
double[,]  
Matrix  
NDSparseArray  

By symmetry both add(A,B) and add(B,A) are available.

The arguments must have the same shapes and the returned expression also has that shape. If one of the arguments is a single scalar, it is promoted to the shape that matches the shape of the other argument, i.e. the scalar is added to all entries of the other argument.

Parameters:
 
  • e1 (Expression) – An expression.
  • e2 (Expression) – An expression.
  • v2 (Variable) – A variable.
  • v1 (Variable) – A variable.
  • a1 (float[]) – A one-dimensional array of constants.
  • a2 (float[][]) – A two-dimensional array of constants.
  • c (float) – A constant.
  • m (Matrix) – A Matrix object.
  • n (NDSparseArray) – An NDSparseArray object.
  • vs (Variable[]) – A list of variables. All variables in the array must have the same shape. The list must contain at least one element.
  • exps (Expression[]) – A list of expressions. All expressions in the array must have the same shape. The list must contain at least one element.
Return:
 

(Expression)

Expr.constTerm
Expr.constTerm(float[] vals1) -> Expression
Expr.constTerm(float[][] vals2) -> Expression
Expr.constTerm(int size, float val) -> Expression
Expr.constTerm(Set shp, float val) -> Expression
Expr.constTerm(float val) -> Expression
Expr.constTerm(Matrix m) -> Expression
Expr.constTerm(NDSparseArray nda) -> Expression

Create an expression consisting of a constant vector of values.

Parameters:
 
  • vals1 (float[]) – A vector initializing the expression.
  • vals2 (float[][]) – A two-dimensional array initializing the expression.
  • size (int) – Length of the vector to be constructed.
  • val (float) – A scalar value to be repeated in all entries of the expression.
  • shp (Set) – Defines the shape of the expression.
  • m (Matrix) – A Matrix of values initializing the expression.
  • nda (NDSparseArray) – An multi-dimensional sparse array initializing the expression.
Return:
 

(Expression)

Expr.dot
Expr.dot(Variable v, float[] a1) -> Expression
Expr.dot(Variable v, float[][] a2) -> Expression
Expr.dot(Variable v, Matrix m) -> Expression
Expr.dot(Variable v, NDSparseArray spm) -> Expression
Expr.dot(Expression expr, NDSparseArray spm) -> Expression
Expr.dot(Expression expr, float[] a1) -> Expression
Expr.dot(Expression expr, float[][] a2) -> Expression
Expr.dot(Expression expr, Matrix m) -> Expression
Expr.dot(float[] a1, Expression expr) -> Expression
Expr.dot(float[] a1, Variable v) -> Expression
Expr.dot(float[][] a2, Expression expr) -> Expression
Expr.dot(float[][] a2, Variable v) -> Expression
Expr.dot(NDSparseArray spm, Expression expr) -> Expression
Expr.dot(NDSparseArray spm, Variable v) -> Expression
Expr.dot(Matrix m, Variable v) -> Expression
Expr.dot(Matrix m, Expression expr) -> Expression

Return an object representing the inner product (dot product) \(x^Ty = \sum_{i=1}^nx_iy_i\) of two objects \(x,y\) of size \(n\).

Both arguments must have the same length when flattened. In particular, they can be two vectors of the same length or two matrices of the same shape.

Parameters:
 
  • v (Variable) – A variable object.
  • a1 (float[]) – A one-dimensional coefficient array.
  • a2 (float[][]) – A two-dimensional coefficient array.
  • m (Matrix) – A matrix object.
  • spm (NDSparseArray) – A multidimensional sparse array object.
  • expr (Expression) – An expression object.
Return:
 

(Expression)

Expr.eval
eval() -> FlatExpr

Evaluate the expression info to a simple array-based form.

Return:
  (FlatExpr)
Expr.flatten
Expr.flatten(Expression e) -> Expression

Reshape the expression into a vector.

Parameters:
 e (Expression)
Return:
  (Expression)
Expr.getModel
getModel() -> Model

Return the model to which the expression belongs

Return:
  (Model)
Expr.getShape
getShape() -> Set

Return the shape of the expression

Return:
  (Set)
Expr.hstack
Expr.hstack(Expression[] exprs) -> Expression
Expr.hstack(Expression e1, Expression e2) -> Expression
Expr.hstack(Expression e1, float a2) -> Expression
Expr.hstack(Expression e1, Variable v2) -> Expression
Expr.hstack(float a1, Variable v2) -> Expression
Expr.hstack(float a1, Expression e2) -> Expression
Expr.hstack(Variable v1, float a2) -> Expression
Expr.hstack(Variable v1, Variable v2) -> Expression
Expr.hstack(Variable v1, Expression e2) -> Expression
Expr.hstack(float a1, float a2, Variable v3) -> Expression
Expr.hstack(float a1, float a2, Expression e3) -> Expression
Expr.hstack(float a1, Variable v2, float a3) -> Expression
Expr.hstack(float a1, Variable v2, Variable v3) -> Expression
Expr.hstack(float a1, Variable v2, Expression e3) -> Expression
Expr.hstack(float a1, Expression e2, float a3) -> Expression
Expr.hstack(float a1, Expression e2, Variable v3) -> Expression
Expr.hstack(float a1, Expression e2, Expression e3) -> Expression
Expr.hstack(Variable v1, float a2, float a3) -> Expression
Expr.hstack(Variable v1, float a2, Variable v3) -> Expression
Expr.hstack(Variable v1, float a2, Expression e3) -> Expression
Expr.hstack(Variable v1, Variable v2, float a3) -> Expression
Expr.hstack(Variable v1, Variable v2, Variable v3) -> Expression
Expr.hstack(Variable v1, Variable v2, Expression e3) -> Expression
Expr.hstack(Variable v1, Expression e2, float a3) -> Expression
Expr.hstack(Variable v1, Expression e2, Variable v3) -> Expression
Expr.hstack(Variable v1, Expression e2, Expression e3) -> Expression
Expr.hstack(Expression e1, float a2, float a3) -> Expression
Expr.hstack(Expression e1, float a2, Variable v3) -> Expression
Expr.hstack(Expression e1, float a2, Expression e3) -> Expression
Expr.hstack(Expression e1, Variable v2, float a3) -> Expression
Expr.hstack(Expression e1, Variable v2, Variable v3) -> Expression
Expr.hstack(Expression e1, Variable v2, Expression e3) -> Expression
Expr.hstack(Expression e1, Expression e2, float a3) -> Expression
Expr.hstack(Expression e1, Expression e2, Variable v3) -> Expression
Expr.hstack(Expression e1, Expression e2, Expression e3) -> Expression

Stack a list of expressions horizontally (i.e. along the second dimension). The expressions must have the same shape, except for the second dimension. The arguments may be any combination of expressions, scalar constants and variables.

For example, if \(x^1,x^2,x^3\) are three vectors of length \(n\) then their horizontal stack is the matrix

\[\begin{split}\left[ \begin{array}{ccc} | & | & | \\ x^1 & x^2 & x^3 \\ | & | & | \end{array}\right]\end{split}\]

of shape (n,3).

Parameters:
 
  • exprs (Expression[]) – A list of expressions.
  • e1 (Expression) – An expression.
  • e2 (Expression) – An expression.
  • a2 (float) – A scalar constant.
  • v2 (Variable) – A variable.
  • a1 (float) – A scalar constant.
  • v1 (Variable) – A variable.
  • v3 (Variable) – A variable.
  • e3 (Expression) – An expression.
  • a3 (float) – A scalar constant.
Return:
 

(Expression)

Expr.index
index(int first) -> Expression
index(int[] firsta) -> Expression

Return a specific term of the expression.

Parameters:
 
  • first (int) – The index of the term in a one-dimensional expression.
  • firsta (int[]) – The indices of the term in a multi-dimensional expression.
Return:
 

(Expression)

Expr.mul
Expr.mul(Matrix mx, Variable v) -> Expression
Expr.mul(Variable v, Matrix mx) -> Expression
Expr.mul(Variable v, float[] vals) -> Expression
Expr.mul(float[] vals, Variable v) -> Expression
Expr.mul(float val, Variable v) -> Expression
Expr.mul(Variable v, float val) -> Expression
Expr.mul(float[][] vals2, Variable v) -> Expression
Expr.mul(Variable v, float[][] vals2) -> Expression
Expr.mul(Expression expr, float val) -> Expression
Expr.mul(float val, Expression expr) -> Expression
Expr.mul(float[] vals, Expression expr) -> Expression
Expr.mul(Expression expr, float[] vals) -> Expression
Expr.mul(Expression expr, Matrix mx) -> Expression
Expr.mul(Matrix mx, Expression expr) -> Expression

Compute the product (in the sense of matrix multiplication or scalar-by-matrix multiplication) of two arguments.

The operands must be at most two-dimensional. One of the arguments must be a constant, a vector of constants or a matrix of constants. The other argument can be a variable or expression. This allows to produce matrix expressions where the entries are linear combinations of variables.

The size and shape of the arguments must adhere to the rules of linear algebra.

Parameters:
 
  • mx (Matrix) – A matrix.
  • v (Variable) – A variable.
  • vals (float[]) – A vector of scalars.
  • val (float) – A scalar value.
  • vals2 (float[][]) – An array of scalars.
  • expr (Expression) – An expression.
Return:
 

(Expression)

Expr.mulDiag
Expr.mulDiag(float[][] a, Expression expr) -> Expression
Expr.mulDiag(Expression expr, float[][] a) -> Expression
Expr.mulDiag(float[][] a, Variable v) -> Expression
Expr.mulDiag(Variable v, float[][] a) -> Expression
Expr.mulDiag(Matrix mx, Expression expr) -> Expression
Expr.mulDiag(Expression expr, Matrix mx) -> Expression
Expr.mulDiag(Matrix mx, Variable v) -> Expression
Expr.mulDiag(Variable v, Matrix mx) -> Expression

Compute the diagonal of the product of two matrices. If \(A\in\mathbb{M}(m,n)\) and \(B\in\mathbb{M}(n,p)\), the result is a vector expression of length \(n\) equal to \(\diag(AB)\).

Parameters:
 
  • a (float[][]) – A constant matrix.
  • expr (Expression) – An expression object.
  • v (Variable) – A variable object.
  • mx (Matrix) – A matrix object.
Return:
 

(Expression)

Expr.mulElm
Expr.mulElm(Variable v, float[] a1) -> Expression
Expr.mulElm(Variable v, float[][] a2) -> Expression
Expr.mulElm(Variable v, NDSparseArray spm) -> Expression
Expr.mulElm(Variable v, Matrix m) -> Expression
Expr.mulElm(Expression expr, NDSparseArray spm) -> Expression
Expr.mulElm(Expression expr, float[] a1) -> Expression
Expr.mulElm(Expression expr, float[][] a2) -> Expression
Expr.mulElm(Expression expr, Matrix m) -> Expression
Expr.mulElm(float[] a1, Expression expr) -> Expression
Expr.mulElm(float[] a1, Variable v) -> Expression
Expr.mulElm(float[][] a2, Expression expr) -> Expression
Expr.mulElm(float[][] a2, Variable v) -> Expression
Expr.mulElm(NDSparseArray spm, Expression expr) -> Expression
Expr.mulElm(NDSparseArray spm, Variable v) -> Expression
Expr.mulElm(Matrix m, Variable v) -> Expression
Expr.mulElm(Matrix m, Expression expr) -> Expression

Returns the element-wise product of two items. The two operands must have the same shape and the returned expression also has this shape.

Parameters:
 
  • v (Variable) – A variable object.
  • a1 (float[]) – A one-dimensional coefficient array.
  • a2 (float[][]) – A two-dimensional coefficient array.
  • spm (NDSparseArray) – A multidimensional sparse array object.
  • m (Matrix) – A matrix object.
  • expr (Expression) – An expression object.
Return:
 

(Expression)

Expr.neg
Expr.neg(Expression e) -> Expression
Expr.neg(Variable v) -> Expression

Return a new expression object representing the given one with opposite sign.

Parameters:
 
Return:
 

(Expression)

Expr.numNonzeros
numNonzeros() -> int

Return the number of non-zero elements in the expression.

Return:
  (int)
Expr.ones
Expr.ones(int num) -> Expression

Create a vector of ones as an expression.

Parameters:
 num (int) – The size of the expression.
Return:
  (Expression)
Expr.outer
Expr.outer(Variable v, float[] a) -> Expression
Expr.outer(float[] a, Variable v) -> Expression
Expr.outer(Variable v, Matrix m) -> Expression
Expr.outer(Matrix m, Variable v) -> Expression
Expr.outer(Expression e, float[] a) -> Expression
Expr.outer(float[] a, Expression e) -> Expression

Return an expression representing the outer product \(xy^T\) of two vectors \(x,y\). If \(x\) has length k and \(y\) has length n then the result is of shape (k,n).

Parameters:
 
  • v (Variable) – A vector variable.
  • a (float[]) – A vector of constants.
  • m (Matrix) – A one-dimensional matrix.
  • e (Expression) – A vector expression.
Return:
 

(Expression)

Expr.pick
pick(int[] indexes) -> Expression
pick(int[][] indexrows) -> Expression

Creates a vector expression by picking elements from the current expression.

Parameters:
 
  • indexes (int[]) – A list of indices specifying positions in a one-dimensional expression.
  • indexrows (int[][]) – A \(n\times m\) array of integers where each row specifies an \(m\)-dimensional index to pick from an \(m\)-dimensional expression.
Return:
 

(Expression)

Expr.repeat
Expr.repeat(Expression e, int n, int d) -> Expression

Repeat an expression a number of times in the given dimension. This is equivalent to stacking \(n\) copies of the expression in dimension \(d\); see Expr.stack.

Parameters:
 
  • e (Expression) – The expression to repeat.
  • n (int) – Number of times to repeat. Must be strictly positive.
  • d (int) – The dimension in which to repeat. Must define a valid dimension index.
Return:
 

(Expression)

Expr.reshape
Expr.reshape(Expression e, Set shp) -> Expression
Expr.reshape(Expression e, int size) -> Expression
Expr.reshape(Expression e, int dimi, int dimj) -> Expression

Reshape the expression into a different shape with the same number of elements.

Parameters:
 
  • e (Expression) – The expression to reshape.
  • shp (Set) – The new shape of the expression; this must have the same total size as the old shape.
  • size (int) – Reshape into a one-dimensional expression of this size.
  • dimi (int) – The first dimension size.
  • dimj (int) – The second dimension size.
Return:
 

(Expression)

Expr.shape
shape() -> Set

Get the shape of the expression.

Return:
  (Set)
Expr.size
size() -> int

Return the expression size, i.e. the product of the lengths along each dimension.

Return:
  (int)
Expr.slice
slice(int first, int last) -> Expression
slice(int[] firsta, int[] lasta) -> Expression

Return a slice of the expression.

Parameters:
 
  • first (int) – The index from which the slice begins.
  • last (int) – The index after the last element of the slice.
  • firsta (int[]) – The indices from which the slice of a multidimensional expression begins.
  • lasta (int[]) – The indices after the last element of slice of a multidimensional expression.
Return:
 

(Expression)

Expr.stack
Expr.stack(int dim, Expression[] exprs) -> Expression
Expr.stack(int dim, Expression e1, Expression e2) -> Expression
Expr.stack(int dim, Expression e1, float a2) -> Expression
Expr.stack(int dim, Expression e1, Variable v2) -> Expression
Expr.stack(int dim, float a1, Variable v2) -> Expression
Expr.stack(int dim, float a1, Expression e2) -> Expression
Expr.stack(int dim, Variable v1, float a2) -> Expression
Expr.stack(int dim, Variable v1, Variable v2) -> Expression
Expr.stack(int dim, Variable v1, Expression e2) -> Expression
Expr.stack(int dim, float a1, float a2, Variable v1) -> Expression
Expr.stack(int dim, float a1, float a2, Expression e1) -> Expression
Expr.stack(int dim, float a1, Variable v2, float a3) -> Expression
Expr.stack(int dim, float a1, Variable v2, Variable v3) -> Expression
Expr.stack(int dim, float a1, Variable v2, Expression e3) -> Expression
Expr.stack(int dim, float a1, Expression e2, float a3) -> Expression
Expr.stack(int dim, float a1, Expression e2, Variable v3) -> Expression
Expr.stack(int dim, float a1, Expression e2, Expression e3) -> Expression
Expr.stack(int dim, Variable v1, float a2, float a3) -> Expression
Expr.stack(int dim, Variable v1, float a2, Variable v3) -> Expression
Expr.stack(int dim, Variable v1, float a2, Expression e3) -> Expression
Expr.stack(int dim, Variable v1, Variable v2, float a3) -> Expression
Expr.stack(int dim, Variable v1, Variable v2, Variable v3) -> Expression
Expr.stack(int dim, Variable v1, Variable v2, Expression e3) -> Expression
Expr.stack(int dim, Variable v1, Expression e2, float a3) -> Expression
Expr.stack(int dim, Variable v1, Expression e2, Variable v3) -> Expression
Expr.stack(int dim, Variable v1, Expression e2, Expression e3) -> Expression
Expr.stack(int dim, Expression e1, float a2, float a3) -> Expression
Expr.stack(int dim, Expression e1, float a2, Variable v3) -> Expression
Expr.stack(int dim, Expression e1, float a2, Expression e3) -> Expression
Expr.stack(int dim, Expression e1, Variable v2, float a3) -> Expression
Expr.stack(int dim, Expression e1, Variable v2, Variable v3) -> Expression
Expr.stack(int dim, Expression e1, Variable v2, Expression e3) -> Expression
Expr.stack(int dim, Expression e1, Expression e2, float a3) -> Expression
Expr.stack(int dim, Expression e1, Expression e2, Variable v3) -> Expression
Expr.stack(int dim, Expression e1, Expression e2, Expression e3) -> Expression
Expr.stack(Expression[][] exprs) -> Expression

Stack a list of expressions along an arbitrary dimension. All expressions must have the same shape, except for dimension dim. The arguments may be any combination of expressions, scalar constants and variables.

For example, suppose \(A,B\) are two \(n\times m\) matrices. Then stacking them in the first dimension produces a matrix of shape (2n,m):

\[\begin{split}\left[\begin{array}{c}A\\ B\end{array}\right],\end{split}\]

stacking them in the second dimension produces a matrix of shape (n,2m):

\[\left[\begin{array}{cc}A & B\end{array}\right],\]

and stacking them in the third dimension produces a three-dimensional array of shape (n,m,2).

The version which takes a two-dimensional array of expressions constructs a block matrix with the given expressions as blocks. The dimensions of the blocks must be suitably compatible.

Parameters:
 
  • dim (int) – The dimension in which to stack.
  • exprs (Expression[]) – A list of expressions.
  • exprs (Expression[][]) – A list of expressions.
  • e1 (Expression) – An expression.
  • e2 (Expression) – An expression.
  • a2 (float) – A scalar constant.
  • v2 (Variable) – A variable.
  • a1 (float) – A scalar constant.
  • v1 (Variable) – A variable.
  • a3 (float) – A scalar constant.
  • v3 (Variable) – A variable.
  • e3 (Expression) – An expression.
Return:
 

(Expression)

Expr.sub
Expr.sub(Expression e1, Expression e2) -> Expression
Expr.sub(Expression e1, Variable v2) -> Expression
Expr.sub(Variable v1, Expression e2) -> Expression
Expr.sub(Expression e1, float[] a1) -> Expression
Expr.sub(Expression e1, float[][] a2) -> Expression
Expr.sub(float[] a1, Expression e2) -> Expression
Expr.sub(float[][] a2, Expression e2) -> Expression
Expr.sub(Expression e1, float c) -> Expression
Expr.sub(float c, Expression e2) -> Expression
Expr.sub(Expression e1, Matrix m) -> Expression
Expr.sub(Matrix m, Expression e2) -> Expression
Expr.sub(Expression e1, NDSparseArray n) -> Expression
Expr.sub(NDSparseArray n, Expression e2) -> Expression
Expr.sub(Variable v1, Variable v2) -> Expression
Expr.sub(Variable v1, float[] a1) -> Expression
Expr.sub(Variable v1, float[][] a2) -> Expression
Expr.sub(float[] a1, Variable v2) -> Expression
Expr.sub(float[][] a2, Variable v2) -> Expression
Expr.sub(Variable v1, float c) -> Expression
Expr.sub(float c, Variable v2) -> Expression
Expr.sub(Variable v1, Matrix m) -> Expression
Expr.sub(Matrix m, Variable v2) -> Expression
Expr.sub(Variable v1, NDSparseArray n) -> Expression
Expr.sub(NDSparseArray n, Variable v2) -> Expression

Computes the difference of two expressions. The expressions must have the same shape and the result will be also an expression of that shape. The allowed combinations of arguments are the same as for Expr.add.

Parameters:
 
  • e1 (Expression) – An expression.
  • e2 (Expression) – An expression.
  • v2 (Variable) – A variable.
  • v1 (Variable) – A variable.
  • a1 (float[]) – An array of constants.
  • a2 (float[][]) – An array of constants.
  • c (float) – A constant.
  • m (Matrix) – A Matrix object.
  • n (NDSparseArray) – An NDSparseArray object.
Return:
 

(Expression)

Expr.sum
Expr.sum(Expression expr) -> Expression
Expr.sum(Variable v) -> Expression
Expr.sum(Variable v, int d) -> Expression
Expr.sum(Variable v, int dfirst, int dlast) -> Expression
Expr.sum(Expression expr, int d) -> Expression
Expr.sum(Expression expr, int dfirst, int dlast) -> Expression

Sum the elements of an expression. Without extra arguments, all elements are summed into a scalar expression of size 1.

With arguments dfirst, dlast or d, elements are summed along a specific dimension or a range of dimensions, resulting in an expression of reduced dimension. Note that the result of summing over a dimension of size 0 is 0.0. This means that for an expression of shape (2,0,2), summing over the second dimension yields an expression of shape (2,2) of zeros.

For example, if the argument is an \(n\times m\) matrix then summing along the first dimension computes the \(1\times m\) vector of column sums, and summing over the second dimension computes the \(n\times 1\) vector of row sums.

Parameters:
 
  • expr (Expression) – An expression object.
  • v (Variable) – A variable.
  • d (int) – The dimension in which to sum.
  • dfirst (int) – The first dimension to sum.
  • dlast (int) – The last-plus-one dimension to sum.
Return:
 

(Expression)

Expr.toString
toString() -> str

Create a human readable string representation of the expression.

Return:
  (str)
Expr.transpose
transpose() -> Expression

Transpose the expression. The expression must have at most two dimensions.

Return:
  (Expression)
Expr.vstack
Expr.vstack(Expression[] exprs) -> Expression
Expr.vstack(Expression e1, Expression e2) -> Expression
Expr.vstack(Expression e1, Variable v2) -> Expression
Expr.vstack(Expression e1, float a2) -> Expression
Expr.vstack(Variable v1, Expression e2) -> Expression
Expr.vstack(Variable v1, Variable v2) -> Expression
Expr.vstack(Variable v1, float a2) -> Expression
Expr.vstack(float a1, Expression e2) -> Expression
Expr.vstack(float a1, Variable v2) -> Expression
Expr.vstack(Expression e1, Expression e2, Expression e3) -> Expression
Expr.vstack(Expression e1, Expression e2, Variable v3) -> Expression
Expr.vstack(Expression e1, Expression e2, float a3) -> Expression
Expr.vstack(Expression e1, Variable v2, Expression e3) -> Expression
Expr.vstack(Expression e1, Variable v2, Variable v3) -> Expression
Expr.vstack(Expression e1, Variable v2, float a3) -> Expression
Expr.vstack(Expression e1, float a2, Expression e3) -> Expression
Expr.vstack(Expression e1, float a2, Variable v3) -> Expression
Expr.vstack(Expression e1, float a2, float a3) -> Expression
Expr.vstack(Variable v1, Expression e2, Expression e3) -> Expression
Expr.vstack(Variable v1, Expression e2, Variable v3) -> Expression
Expr.vstack(Variable v1, Expression e2, float a3) -> Expression
Expr.vstack(Variable v1, Variable v2, Expression e3) -> Expression
Expr.vstack(Variable v1, Variable v2, Variable v3) -> Expression
Expr.vstack(Variable v1, Variable v2, float a3) -> Expression
Expr.vstack(Variable v1, float a2, Expression e3) -> Expression
Expr.vstack(Variable v1, float a2, Variable v3) -> Expression
Expr.vstack(Variable v1, float a2, float a3) -> Expression
Expr.vstack(float a1, Expression e2, Expression e3) -> Expression
Expr.vstack(float a1, Expression e2, Variable v3) -> Expression
Expr.vstack(float a1, Expression e2, float a3) -> Expression
Expr.vstack(float a1, Variable v2, Expression e3) -> Expression
Expr.vstack(float a1, Variable v2, Variable v3) -> Expression
Expr.vstack(float a1, Variable v2, float a3) -> Expression
Expr.vstack(float a1, float a2, Expression e3) -> Expression
Expr.vstack(float a1, float a2, Variable v3) -> Expression
Expr.vstack(float a1, float a2, float a3) -> Expression

Stack a list of expressions vertically (i.e. along the first dimension). The expressions must have the same shape, except for the first dimension. The arguments may be any combination of expressions, scalar constants and variables.

For example, if \(y^1,y^2,y^3\) are three horizontal vectors of length \(n\) (and shape (1,n)) then their vertical stack is the matrix

\[\begin{split}\left[ \begin{array}{c}- y^1 - \\ - y^2 - \\ - y^3 - \end{array}\right]\end{split}\]

of shape (3,n).

Parameters:
 
  • exprs (Expression[]) – A list of expressions.
  • e1 (Expression) – An expression.
  • e2 (Expression) – An expression.
  • v2 (Variable) – A variable.
  • a2 (float) – A scalar constant.
  • v1 (Variable) – A variable.
  • a1 (float) – A scalar constant.
  • e3 (Expression) – An expression.
  • v3 (Variable) – A variable.
  • a3 (float) – A scalar constant.
Return:
 

(Expression)

Expr.zeros
Expr.zeros(int num) -> Expression

Create a vector of zeros as an expression.

Parameters:
 num (int) – The size of the expression.
Return:
  (Expression)