Struct ExprAdd 

pub struct ExprAdd<const N: usize, L: ExprTrait<N>, R: ExprTrait<N>> { /* private fields */ }

Implementations

impl<const N: usize, L, R> ExprAdd<N, L, R>

where L: ExprTrait<N>, R: ExprTrait<N>,

pub fn new(lhs: L, rhs: R, lcof: f64, rcof: f64) -> ExprAdd<N, L, R>

pub fn add<T>(self, rhs: T) -> ExprAddRec<N, ExprAdd<N, L, R>, T::Result>

where Self: Sized, T: IntoExpr<N>,

This will by default override add() defined for ExprTraint<N>, allowing us to create a recursive add structure in stead of just nested adds.

pub fn sub<T>(self, rhs: T) -> ExprAddRec<N, ExprAdd<N, L, R>, T::Result>

where Self: Sized, T: IntoExpr<N>,

This will by default override add() defined for ExprTraint<N>, allowing us to create a recursive add structure in stead of just nested adds.

Trait Implementations

impl<const N: usize, L, R> ExprAddRecTrait for ExprAdd<N, L, R>

where L: ExprTrait<N>, R: ExprTrait<N>,

fn eval_rec( &self, c: f64, rs: &mut WorkStack, ws: &mut WorkStack, xs: &mut WorkStack, ) -> Result<usize, ExprEvalError>

impl<const N: usize, L, R> ExprTrait<N> for ExprAdd<N, L, R>

where L: ExprTrait<N>, R: ExprTrait<N>,

fn eval( &self, rs: &mut WorkStack, ws: &mut WorkStack, xs: &mut WorkStack, ) -> Result<(), ExprEvalError>

Evaluate the expression and put the result on the rs stack, using the ws to evaluate sub-expressions and xs for general storage. The job of eval is to evaluate all sub-expressions and compute the flattened expression from this (basically, coefficients and subscripts of the expression). Upon return, the rs stack must hold the result of the evaluation.

fn eval_finalize( &self, rs: &mut WorkStack, ws: &mut WorkStack, xs: &mut WorkStack, ) -> Result<(), ExprEvalError>

Evaluate the expression, then clean it up and put it on the rs stack. The result will guarantee that

fn dynamic<'a>(self) -> ExprDynamic<'a, N>

where Self: Sized + 'a,

Create a dynamic expression from an expression. Expression types generally depend on the types of all the sub-expressions, so it is not possible to make e.g. an array of expressions unless they are exactly the same types. Wrapping each expression in a dynamic expression allows us to create structures like arrays that requires all elements to have the same type. The down-side is heap-allocated objects and that eval() calls are dynamic.

fn axispermute(self, perm: &[usize; N]) -> ExprPermuteAxes<N, Self>

where Self: Sized,

Permute axes of the expression. Permute the index coordinates of each entry in the expression, and similarly permute the shape. This is a generalized transpose operation, so in two dimensions this is just a regular transpose.

fn sum(self) -> ExprSum<N, Self>

where Self: Sized,

Sum all elements in an expression producing a scalar expression.

fn neg(self) -> ExprMulScalar<N, Self>

where Self: Sized,

Negate coefficients of all elements in the expression.

fn sum_on<const K: usize>( self, axes: &[usize; K], ) -> ExprReduceShape<N, K, ExprSumLastDims<N, ExprPermuteAxes<N, Self>>>

where Self: Sized,

Sum over a number of axes, reducing the dimensionality of the expression.

fn add<RHS>(self, rhs: RHS) -> ExprAdd<N, Self, RHS::Result>

where RHS: IntoExpr<N>, Self: Sized,

Add an expression and an item that is addable to an expression, e.g. constants or other expressions.

fn sub<RHS>(self, rhs: RHS) -> ExprAdd<N, Self, RHS::Result>

where RHS: IntoExpr<N>, Self: Sized,

Subtract expression and an item that is addable to an expression, e.g. constants or other expressions.

fn dot<RHS>(self, rhs: RHS) -> RHS::Result

where RHS: RightDottable<N, Self>, Self: Sized,

fn mul_elem<RHS>(self, other: RHS) -> RHS::Result

where Self: Sized, RHS: ExprRightElmMultipliable<N, Self>,

Element-wise multiplication of two operands. The operand shapes must be the same.

fn dot_rows<M>(self, other: M) -> ExprDotRows<Self>

where Self: ExprTrait<2> + Sized, M: Matrix,

An expression that produces a vector of dot-products of the rows of the operands, specifically, [r_0,r_1,...] = [dot(e_{0,*},m_{0,*},dot(e_{1,*},m_{1,*},...], where e if an expression and m is a matrix. The shapes of the operands must be identical.

fn vstack<E>(self, other: E) -> ExprStack<N, Self, E::Result>

where Self: Sized, E: IntoExpr<N>,

Stack vertically, i.e. in first dimension. The two operands have the same number of dimensions, and must have the same shapes except in the first dimension. N must be at least 1.

fn hstack<E>(self, other: E) -> ExprStack<N, Self, E::Result>

where Self: Sized, E: IntoExpr<N>,

Stack horizontally, i.e. stack in second dimension. The two operands have the same number of dimensions, and must have the same shapes except in the second dimension. N must be at least 2.

fn stack<E>(self, dim: usize, other: E) -> ExprStack<N, Self, E::Result>

where Self: Sized, E: IntoExpr<N>,

Stack in arbitrary dimension. The two operands have the same number of dimensions, and must have the same shapes except in dimension dim. N must be larger than or equal to dim

fn repeat(self, dim: usize, num: usize) -> ExprRepeat<N, Self>

where Self: Sized,

Repeat a fixed number of times in the given dimension.

fn index<I>(self, idx: I) -> I::Output

where I: ModelExprIndex<Self>, Self: Sized,

Indexing or slicing an expression. This is not compatible with std::ops::Index since we need to return a new object rather than a reference to an object, so sugary syntax is not possible here.

fn reshape<const M: usize>(self, shape: &[usize; M]) -> ExprReshape<N, M, Self>

where Self: Sized,

Reshape the experssion. The new shape must match the old shape, meaning that the product of the dimensions are the same. The function will panic if operand shapes do not match.

fn into_symmetric(self, dim: usize) -> ExprIntoSymmetric<N, Self>

where Self: Sized,

Create an expression that is symmetric in dimension dim and dim+1. The shape must satisfy the following:

fn flatten(self) -> ExprReshapeOneRow<N, 1, Self>

where Self: Sized,

Flatten the expression into a vector. Preserve sparsity.

fn into_column(self) -> ExprReshapeOneRow<N, 2, Self>

where Self: Sized,

Flatten expression into a column, i.e. an expression of size [n,1] where n=shape.iter().product().

fn into_vec<const M: usize>(self, i: usize) -> ExprReshapeOneRow<N, M, Self>

where Self: Sized + ExprTrait<1>,

Reshape an expression into a vector expression, where all but (at most) one dimension are of size 1.

fn gather(self) -> ExprGatherToVec<N, Self>

where Self: Sized,

Reshape a sparse expression into a dense expression vector. The length of the vector cannot be known until the expression is evaluated.

fn map<const M: usize, F>( self, shape: &[usize; M], f: F, ) -> ExprMap<N, M, F, Self>

where F: Clone + FnMut(&[usize; N]) -> Option<[usize; M]>, Self: Sized,

Map each nonzero to a new position in an expression with a new shape.

fn flip(self, dims: &[bool; N]) -> ExprFlip<N, Self>

where Self: Sized,

Flip elements in a subset of dimensions.

fn mul<RHS>(self, other: RHS) -> RHS::Result

where Self: Sized, RHS: ExprRightMultipliable<N, Self>,

Multiply (self * other), where other must be right-multipliable with Self.

fn rev_mul<LHS>(self, lhs: LHS) -> LHS::Result

where Self: Sized, LHS: ExprLeftMultipliable<N, Self>,

Multiply (other * self), where other must be left-multipliable with Self.

fn transpose(self) -> ExprPermuteAxes<2, Self>

where Self: Sized + ExprTrait<2>,

Transpose a two-dimensional expression.

fn tril(self, with_diag: bool) -> ExprTriangularPart<Self>

where Self: Sized + ExprTrait<2>,

Create a new expression with only lower triangular nonzeros from the operand.

fn triu(self, with_diag: bool) -> ExprTriangularPart<Self>

where Self: Sized + ExprTrait<2>,

Create a new expression with only upper triangular nonzeros from the operand.

fn trilvec( self, with_diag: bool, ) -> ExprGatherToVec<2, ExprTriangularPart<Self>>

where Self: Sized + ExprTrait<2>,

create a new expression with only lower triangular nonzeros from the operand put into a vector in row-order.

fn triuvec( self, with_diag: bool, ) -> ExprGatherToVec<2, ExprTriangularPart<Self>>

where Self: Sized + ExprTrait<2>,

Create a new expression with only upper triangular nonzeros from the operand.

fn diag(self) -> ExprDiag<Self>

where Self: Sized + ExprTrait<2>,

Take the diagonal elements if a square matrix and return it as a new vector expression.

fn square_diag(self) -> ExprSquareDiag<Self>

where Self: Sized + ExprTrait<1>,

Create a sparse square matrix with the vector expression elements as diagonal.

fn mul_any_scalar(self, c: f64) -> ExprMulScalar<N, Self>

where Self: Sized,

Internal. Should normally not be called directly.

fn mul_matrix_const_matrix<M>(self, m: &M) -> ExprMulRight<Self>

where Self: Sized + ExprTrait<2>, M: Matrix,

Internal. Should normally not be called directly.

fn mul_rev_matrix_const_matrix<M>(self, m: &M) -> ExprMulLeft<Self>

where Self: Sized + ExprTrait<2>, M: Matrix,

Internal. Should normally not be called directly.

fn mul_matrix_vec( self, v: Vec<f64>, ) -> ExprReshapeOneRow<2, 1, ExprMulRight<Self>>

where Self: Sized + ExprTrait<2>,

Internal. Should normally not be called directly.

fn mul_rev_matrix_vec( self, v: Vec<f64>, ) -> ExprReshapeOneRow<2, 1, ExprMulLeft<Self>>

where Self: Sized + ExprTrait<2>,

Internal. Should normally not be called directly.

fn mul_vec_matrix<M>( self, m: &M, ) -> ExprReshapeOneRow<2, 1, ExprMulRight<ExprReshapeOneRow<1, 2, Self>>>

where Self: Sized + ExprTrait<1>, M: Matrix,

Internal. Should normally not be called directly.

fn mul_rev_vec_matrix<M>( self, m: &M, ) -> ExprReshapeOneRow<2, 1, ExprMulRight<ExprReshapeOneRow<1, 2, Self>>>

where Self: Sized + ExprTrait<1>, M: Matrix,

Internal. Should normally not be called directly.

fn mul_scalar_matrix<M>( self, m: &M, ) -> ExprReshape<1, 2, ExprMulElm<1, ExprRepeat<1, ExprReshape<0, 1, Self>>>>

where Self: Sized + ExprTrait<0>, M: Matrix,

Internal. Should normally not be called directly.