14.2.13 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.
- Implements:
- Members:
BaseExpression.getDim – Return the d’th dimension in the expression.
BaseExpression.getND – Return the number of dimensions in the expression.
BaseExpression.getShape – Get the shape of the expression.
BaseExpression.getSize – Return the total number of elements in the expression (the product of the dimensions).
BaseExpression.index ([]) – Get a single element in the expression.
BaseExpression.pick ([]) – Pick a number of elements from the expression.
BaseExpression.slice ([]) – Get a slice of the expression.
BaseExpression.toString – Return a string representation of the expression object.
Expr.eval – Evaluate the expression and push the result onto the work stack.
- Static members:
Expr.add (+) – Compute the sum of expressions.
Expr.condense – Flatten expression and remove all structural zeros.
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 an expression consisting of ones.
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.transpose (.T) – Transpose a two-dimensional expression.
Expr.vstack – Stack a list of expressions vertically (i.e. along the first dimension).
Expr.zeros – Create an expression consisting of zeros.
- Expr.add (+)¶
Expr.add(Expression e1, 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[] 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)
andadd(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.
The standard Python operator
+
can also be used for this purpose. See Sec. 14.1.3 (Pythonic extensions) for details.- Parameters:
e1
(Expression
) – An expression.e2
(Expression
) – An expression.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:
- Expr.condense¶
Expr.condense(Expression e) -> Expression
Flatten expression and remove all structural zeros.
- Parameters:
e
(Expression
) – Expression to be condensed.- Return:
- Expr.constTerm¶
Expr.constTerm(float[] vals1) -> Expression Expr.constTerm(float[][] vals2) -> Expression Expr.constTerm(int size, float val) -> Expression Expr.constTerm(int[] shp, float val) -> Expression Expr.constTerm(int[] shp, int[][] sparsity, float[] vals1) -> Expression Expr.constTerm(int[] shp, int[][] sparsity, 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
[][]) – An 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
(int
[]) – Defines the shape of the expression.sparsity
(int
[][]) – Sparsity pattern.m
(Matrix
) – A matrix of values initializing the expression.nda
(NDSparseArray
) – An multi-dimensional sparse array initializing the expression.
- Return:
- Expr.dot¶
Expr.dot(Parameter p, Expression e) -> Expression Expr.dot(Expression e, Parameter p) -> Expression Expr.dot(float[] c1, Expression e) -> Expression Expr.dot(float[][] c2, Expression e) -> Expression Expr.dot(NDSparseArray nda, Expression e) -> Expression Expr.dot(Matrix m, Expression e) -> Expression Expr.dot(Expression e, float[] c1) -> Expression Expr.dot(Expression e, NDSparseArray nda) -> Expression Expr.dot(Expression e, float[][] c2) -> Expression Expr.dot(Expression e, Matrix m) -> 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:
p
(Parameter
) – A parameter.e
(Expression
) – An expression object.c1
(float
[]) – A one-dimensional coefficient vector.c2
(float
[][]) – A two-dimensional coefficient array.nda
(NDSparseArray
) – A multi-dimensional sparse array.m
(Matrix
) – A matrix object.
- Return:
- Expr.eval¶
eval(WorkStack rs, WorkStack ws, WorkStack xs)
Evaluate the expression and push the result onto the
rs
work stack.
- Expr.flatten¶
Expr.flatten(Expression e) -> Expression
Reshape the expression into a vector.
- Parameters:
e
(Expression
) – The expression to be flattened.- Return:
- Expr.hstack¶
Expr.hstack(Expression[] exprs) -> Expression Expr.hstack(Expression e1, Expression e2) -> Expression Expr.hstack(Expression e1, float a2) -> Expression Expr.hstack(float a1, Expression e2) -> Expression Expr.hstack(float a1, float a2, Expression e3) -> Expression Expr.hstack(float a1, Expression e2, float a3) -> Expression Expr.hstack(float a1, Expression e2, Expression e3) -> Expression Expr.hstack(Expression e1, float a2, float a3) -> Expression Expr.hstack(Expression e1, float a2, Expression e3) -> Expression Expr.hstack(Expression e1, Expression e2, float a3) -> 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.a1
(float
) – A scalar constant.e3
(Expression
) – An expression.a3
(float
) – A scalar constant.
- Return:
- Expr.mul (*,@)¶
Expr.mul(Parameter p, Expression expr) -> Expression Expr.mul(Expression expr, Parameter p) -> Expression Expr.mul(Matrix mx, Variable v) -> Expression Expr.mul(Variable v, Matrix mx) -> Expression Expr.mul(float[][] mx, Variable v) -> Expression Expr.mul(Variable v, float[][] mx) -> Expression Expr.mul(Matrix mx, Expression expr) -> Expression Expr.mul(Expression expr, Matrix mx) -> Expression Expr.mul(float[][] a, Expression expr) -> Expression Expr.mul(Expression expr, float[][] a) -> Expression Expr.mul(float[] a, Expression expr) -> Expression Expr.mul(Expression expr, float[] a) -> Expression Expr.mul(float c, Expression expr) -> Expression Expr.mul(Expression expr, float c) -> 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.
The standard Python operators
*,@
can also be used for this purpose. See Sec. 14.1.3 (Pythonic extensions) for details.- Parameters:
p
(Parameter
) – A parameter object.expr
(Expression
) – An expression.mx
(Matrix
) – A matrix.mx
(float
[][]) – A matrix.v
(Variable
) – A variable.a
(float
[][]) – Scalar data.a
(float
[]) – Scalar data.c
(float
) – A scalar value.
- Return:
- Expr.mulDiag¶
Expr.mulDiag(float[][] a, Expression expr) -> Expression Expr.mulDiag(float[][] a, Variable v) -> Expression Expr.mulDiag(Expression expr, float[][] a) -> 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 Expr.mulDiag(Parameter p, Expression expr) -> Expression Expr.mulDiag(Expression expr, Parameter p) -> Expression Expr.mulDiag(Parameter p, Variable v) -> Expression Expr.mulDiag(Variable v, Parameter p) -> Expression
Compute the diagonal of the product of two matrices. If \(A\in\mathbb{M}(m,n)\) and \(B\in\mathbb{M}(n,m)\), the result is a vector expression of length \(m\) 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.p
(Parameter
) – A parameter object.
- Return:
- Expr.mulElm¶
Expr.mulElm(Expression expr, Parameter p) -> Expression Expr.mulElm(Parameter p, Expression expr) -> 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[][] a2, Expression expr) -> Expression Expr.mulElm(NDSparseArray spm, Expression expr) -> 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:
expr
(Expression
) – An expression object.p
(Parameter
) – A parameter object.spm
(NDSparseArray
) – A multidimensional sparse array object.a1
(float
[]) – A one-dimensional coefficient array.a2
(float
[][]) – A two-dimensional coefficient array.m
(Matrix
) – A matrix object.
- Return:
- Expr.neg (-)¶
Expr.neg(Expression e) -> Expression
Return a new expression object representing the given one with opposite sign.
The standard Python operator
-
can also be used for this purpose. See Sec. 14.1.3 (Pythonic extensions) for details.- Parameters:
e
(Expression
) – An expression object.- Return:
- Expr.ones¶
Expr.ones(int size) -> Expression Expr.ones(int[] shp) -> Expression Expr.ones(int[] shp, int[][] sparsity) -> Expression Expr.ones() -> Expression
Create an expression consisting of ones.
- Parameters:
size
(int
) – Length of the vector to be constructed.shp
(int
[]) – Defines the shape of the expression.sparsity
(int
[][]) – Defines the sparsity pattern of the expression - everything outside the sparsitry patterm will be zero.
- Return:
- Expr.outer¶
Expr.outer(Expression e, float[] a) -> Expression Expr.outer(float[] a, Expression e) -> Expression Expr.outer(Expression e, Matrix m) -> Expression Expr.outer(Matrix m, Expression e) -> Expression Expr.outer(Expression e, Parameter p) -> Expression Expr.outer(Parameter p, 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 lengthn
then the result is of shape(k,n)
.- Parameters:
e
(Expression
) – A vector expression.a
(float
[]) – A vector of constants.m
(Matrix
) – A one-dimensional matrix.p
(Parameter
) – A vector parameter.
- Return:
- Expr.repeat¶
Expr.repeat(Expression e, int n, int d) -> Expression Expr.repeat(Variable x, 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.x
(Variable
) – The variable to repeat.
- Return:
- Expr.reshape¶
Expr.reshape(Expression e, int[] newshape) -> 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.newshape
(int
[]) – Reshape into an expression of this 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:
- 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, float a1, Expression e2) -> Expression Expr.stack(int dim, float a1, float a2, Expression e1) -> Expression Expr.stack(int dim, float a1, Expression e2, float a3) -> Expression Expr.stack(int dim, float a1, Expression e2, Expression e3) -> Expression Expr.stack(int dim, Expression e1, float a2, float a3) -> Expression Expr.stack(int dim, Expression e1, float a2, Expression e3) -> Expression Expr.stack(int dim, Expression e1, Expression e2, float a3) -> 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.a1
(float
) – A scalar constant.a3
(float
) – A scalar constant.e3
(Expression
) – An expression.
- Return:
- Expr.sub (-)¶
Expr.sub(Expression e1, 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
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 (+)
.The standard Python operator
-
can also be used for this purpose. See Sec. 14.1.3 (Pythonic extensions) for details.- Parameters:
e1
(Expression
) – An expression.e2
(Expression
) – An expression.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:
- Expr.sum¶
Expr.sum(Expression expr) -> Expression Expr.sum(Expression expr, int dim) -> Expression
Sum the elements of an expression. Without extra arguments, all elements are summed into a scalar expression of size 1.
With argument
dim
, elements are summed along a specific dimension, 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 \(0\)-th dimension computes the \(1\times m\) vector of column sums, and summing along the \(1\)-st dimension computes the \(n\times 1\) vector of row sums.
- Parameters:
expr
(Expression
) – An expression object.dim
(int
) – The dimension along which to sum.
- Return:
- Expr.transpose (.T)¶
Expr.transpose(Expression e) -> Expression
Transpose a two-dimensional expression.
The standard Python operator
.T
can also be used for this purpose. See Sec. 14.1.3 (Pythonic extensions) for details.- Parameters:
e
(Expression
) – Expression to transpose.- Return:
- Expr.vstack¶
Expr.vstack(Expression[] exprs) -> Expression Expr.vstack(Expression e1, Expression e2) -> Expression Expr.vstack(Expression e1, float a2) -> Expression Expr.vstack(float a1, Expression e2) -> Expression Expr.vstack(Expression e1, Expression e2, Expression e3) -> Expression Expr.vstack(Expression e1, Expression e2, float a3) -> Expression Expr.vstack(Expression e1, float a2, Expression e3) -> Expression Expr.vstack(Expression e1, float a2, float a3) -> Expression Expr.vstack(float a1, Expression e2, Expression e3) -> Expression Expr.vstack(float a1, Expression e2, float a3) -> Expression Expr.vstack(float a1, float a2, Expression e3) -> 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.a2
(float
) – A scalar constant.a1
(float
) – A scalar constant.e3
(Expression
) – An expression.a3
(float
) – A scalar constant.
- Return:
- Expr.zeros¶
Expr.zeros(int size) -> Expression Expr.zeros(int[] shp) -> Expression
Create an expression consisting of zeros.
- Parameters:
size
(int
) – Length of the vector to be constructed.shp
(int
[]) – Defines the shape of the expression.
- Return: