operator*#

BasicBilinearForm &xlifepp::operator*(const BasicBilinearForm&, const BasicBilinearForm&)#: compose two basic bilinear forms

BilinearForm xlifepp::operator*(const BilinearForm&, const BilinearForm&)#: compose two bilinear forms, have to be basic linear forms

BilinearForm xlifepp::operator*(const BilinearForm&, const complex_t&)#: product(right) by a complex scalar

BilinearForm xlifepp::operator*(const BilinearForm&, const int&)#: product(right) by an integer scalar

BilinearForm xlifepp::operator*(const BilinearForm&, const int_t&)#: product(right) by an integer scalar

BilinearForm xlifepp::operator*(const BilinearForm&, const number_t&)#: product(right) by an integer scalar

BilinearForm xlifepp::operator*(const BilinearForm&, const real_t&)#: product(right) by a real scalar

BilinearForm xlifepp::operator*(const complex_t&, const BilinearForm&)#: product(left) by a complex scalar

LinearForm xlifepp::operator*(const complex_t&, const LinearForm&)#: product(left) by a scalar

SuBilinearForm xlifepp::operator*(const complex_t&, const SuBilinearForm&)#: multiply(left) by a scalar

OperatorOnUnknown &xlifepp::operator*(const complex_t&, const Unknown&)#: c*u

Vector<Vector<complex_t>> xlifepp::operator*(const complex_t&, const Vector<Vector<complex_t>>&)#: multiply complex scalar by complex vector “x * A”

LcKernelOperatorOnUnknowns xlifepp::operator*(const complex_t &a, const LcKernelOperatorOnUnknowns &lc)#

LcOperatorOnUnknown xlifepp::operator*(const complex_t &a, const LcOperatorOnUnknown &lc)#

LcOperatorOnUnknowns xlifepp::operator*(const complex_t &a, const LcOperatorOnUnknowns &lc)#

SuLinearForm xlifepp::operator*(const complex_t &c, const SuLinearForm &sulf)#: product(left) by a scalar

inline SymbolicFunction &xlifepp::operator*(const complex_t &c, const SymbolicFunction &f)#

SymbolicTermMatrix &xlifepp::operator*(const complex_t &c, SymbolicTermMatrix &S)#

Parameter xlifepp::operator*(const complex_t &v, const Parameter &p)#: product complex and parameter

OperatorOnFunction &xlifepp::operator*(const complex_t &v, UnitaryVector n)#: v*n same as f_v*n

OperatorOnUnknown &xlifepp::operator*(const complex_t &val, OperatorOnUnknown &opu)#

Matrix<complex_t> xlifepp::operator*(const complex_t &x, const Matrix<real_t> &rA)#

multiply real matrix by a complex value

complex x * real matrix A

Vector<complex_t> xlifepp::operator*(const complex_t &x, const Vector<real_t> &rA)#

multiply real vector by complex scalar

multiply real vector by complex scalar “x * A”

complex_t xlifepp::operator*(const complex_t &z, const int i)#

complex_t xlifepp::operator*(const complex_t &z, const int_t i)#

complex_t xlifepp::operator*(const complex_t &z, const number_t n)#

LargeMatrix<complex_t> xlifepp::operator*(const complex_t v, const LargeMatrix<real_t> &mat)#

OperatorOnFunction &xlifepp::operator*(const Extension &e, const Function &f)#: extension of Function

OperatorOnKernel &xlifepp::operator*(const Extension &e, const Kernel &k)#: extension of Kernel

OperatorOnFunction &xlifepp::operator*(const Extension &e, OperatorOnFunction &opf)#: extension of OperatorOnFunction

OperatorOnKernel &xlifepp::operator*(const Extension &e, OperatorOnKernel &opk)#: extension of OperatorOnKernel

OperatorOnUnknown &xlifepp::operator*(const Function&, const Unknown&)#: F*u.

OperatorOnUnknown &xlifepp::operator*(const Function&, OperatorOnUnknown&)#: product syntax F*Op(u)

OperatorOnFunction &xlifepp::operator*(const Function&, UnitaryVector)#: f*n same as timesn(f)/timesncrossn(f)

template<typename T, typename I> Vector<T> xlifepp::operator*(const HMatrix<T, I> &h, const Vector<T> &x)#: Hmatrix * Vector.

BilinearForm xlifepp::operator*(const int&, const BilinearForm&)#: product(left) by an integer scalar

LinearForm xlifepp::operator*(const int&, const LinearForm&)#: product(left) by a scalar

complex_t xlifepp::operator*(const int i, const complex_t &z)#

Parameter xlifepp::operator*(const int v, const Parameter &p)#: product int and parameter

BilinearForm xlifepp::operator*(const int_t&, const BilinearForm&)#: product(left) by an integer scalar

LinearForm xlifepp::operator*(const int_t&, const LinearForm&)#: product(left) by a scalar

complex_t xlifepp::operator*(const int_t i, const complex_t &z)#

Parameter xlifepp::operator*(const int_t v, const Parameter &p)#: product int_t and parameter

template<typename K> PolynomialT<K> xlifepp::operator*(const K &k, const MonomialT<K> &m)#

template<typename K> PolynomialT<K> xlifepp::operator*(const K &k, const PolynomialT<K> &p)#

template<typename K> Vector<K> xlifepp::operator*(const K &x, const Vector<K> &a)#: multiply vector by a scalar “x * A”

template<typename K> Vector<Matrix<K>> xlifepp::operator*(const K &x, const Vector<Matrix<K>> &a)#: scalar x * vector of matrix

KernelOperatorOnUnknowns xlifepp::operator*(const Kernel&, const OperatorOnUnknown&)#: ker * opv

KernelOperatorOnUnknowns xlifepp::operator*(const Kernel&, const Unknown&)#: ker * v

OperatorOnKernel &xlifepp::operator*(const Kernel&, UnitaryVector)#: ker*n same as ntimes(ker)

KernelOperatorOnTermVector xlifepp::operator*(const Kernel &ker, const TermVector &tv)#: ker * tv

KernelOperatorOnTermVectorAndUnknown xlifepp::operator*(const KernelOperatorOnTermVector &koptv, const OperatorOnUnknown &opv)#

KernelOperatorOnTermVectorAndUnknown xlifepp::operator*(const KernelOperatorOnTermVector &koptv, const Unknown &v)#

KernelOperatorOnTermVectorAndUnknown xlifepp::operator*(const KernelOperatorOnTermVectorAndUnknown&, const OperatorOnUnknown&)#

KernelOperatorOnUnknowns xlifepp::operator*(const KernelOperatorOnUnknowns&, const OperatorOnUnknown&)#: opker * opv

KernelOperatorOnUnknowns xlifepp::operator*(const KernelOperatorOnUnknowns&, const Unknown&)#: opker * v

template<typename K, typename KK> VectorEigenDense<K> xlifepp::operator*(const KK &k, const VectorEigenDense<K> &vec)#

template<typename K, typename KK> Matrix<K> xlifepp::operator*(const KK &x, const Matrix<K> &a)#: scalar x * matrix A

template<typename K, typename KK> SparseMatrix<K> xlifepp::operator*(const KK &x, const SparseMatrix<K> &a)#: scalar x * matrix A

LargeMatrix<complex_t> xlifepp::operator*(const LargeMatrix<complex_t> &mA, const LargeMatrix<real_t> &mB)#

LargeMatrix<complex_t> xlifepp::operator*(const LargeMatrix<complex_t> &mat, const real_t v)#

std::vector<complex_t> xlifepp::operator*(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec)#

LargeMatrix<Matrix<complex_t>> xlifepp::operator*(const LargeMatrix<Matrix<complex_t>> &mA, const LargeMatrix<Matrix<real_t>> &mB)#

std::vector<Vector<complex_t>> xlifepp::operator*(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec)#

LargeMatrix<Matrix<complex_t>> xlifepp::operator*(const LargeMatrix<Matrix<real_t>> &mA, const LargeMatrix<Matrix<complex_t>> &mB)#

std::vector<Vector<complex_t>> xlifepp::operator*(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec)#

template<typename T> std::vector<Vector<T>> xlifepp::operator*(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec)#

LargeMatrix<complex_t> xlifepp::operator*(const LargeMatrix<real_t> &mA, const LargeMatrix<complex_t> &mB)#

LargeMatrix<complex_t> xlifepp::operator*(const LargeMatrix<real_t> &mat, const complex_t v)#

std::vector<complex_t> xlifepp::operator*(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec)#

template<typename T> LargeMatrix<T> xlifepp::operator*(const LargeMatrix<T> &mA, const LargeMatrix<T> &mB)#

template<typename T> std::vector<T> xlifepp::operator*(const LargeMatrix<T> &mat, const std::vector<T> &vec)#

template<typename T> LargeMatrix<T> xlifepp::operator*(const LargeMatrix<T> &mat, const T v)#: Multiple a largeMatrix with a scalar.

LcKernelOperatorOnUnknowns xlifepp::operator*(const LcKernelOperatorOnUnknowns &lc, const complex_t &a)#

LcKernelOperatorOnUnknowns xlifepp::operator*(const LcKernelOperatorOnUnknowns &lc, const real_t &a)#

LcOperatorOnUnknown xlifepp::operator*(const LcOperatorOnUnknown &lc, const complex_t &a)#

LcOperatorOnUnknown xlifepp::operator*(const LcOperatorOnUnknown &lc, const real_t &a)#

LcOperatorOnUnknowns xlifepp::operator*(const LcOperatorOnUnknown &lcopu, const LcOperatorOnUnknown &lcopv)#

LcOperatorOnUnknowns xlifepp::operator*(const LcOperatorOnUnknown &lcopu, const OperatorOnUnknown &opv)#

LcOperatorOnUnknowns xlifepp::operator*(const LcOperatorOnUnknown &lcopu, const Unknown &v)#

LcOperatorOnUnknowns xlifepp::operator*(const LcOperatorOnUnknowns &lc, const complex_t &a)#

LcOperatorOnUnknowns xlifepp::operator*(const LcOperatorOnUnknowns &lc, const real_t &a)#

TermVector xlifepp::operator*(const LcTerm<TermMatrix>&, const TermVector&)#: LcTerm * TermVector.

template<typename TT, typename T> LcTerm<TT> xlifepp::operator*(const LcTerm<TT> &lc, const T &v)#

LinearForm xlifepp::operator*(const LinearForm&, const complex_t&)#: product(right) by a scalar

LinearForm xlifepp::operator*(const LinearForm&, const int&)#: product(right) by a scalar

LinearForm xlifepp::operator*(const LinearForm&, const int_t&)#: product(right) by a scalar

LinearForm xlifepp::operator*(const LinearForm&, const number_t&)#: product(right) by a scalar

LinearForm xlifepp::operator*(const LinearForm&, const real_t&)#: product(right) by a scalar

template<typename T> LowRankMatrix<T> xlifepp::operator*(const LowRankMatrix<T> &L1, const T &s)#

template<typename T> std::vector<T> xlifepp::operator*(const LowRankMatrix<T> &lrm, const std::vector<T> &x)#

Matrix<complex_t> xlifepp::operator*(const Matrix<complex_t> &cA, const Matrix<real_t> &rB)#

multiply complex matrix by a real matrix

complex matrix A x real matrix B

Vector<complex_t> xlifepp::operator*(const Matrix<complex_t> &cA, const Vector<real_t> &rV)#

complex matrix * real vector

complex matrix x real vector

OperatorOnFunction &xlifepp::operator*(const Matrix<complex_t> &v, UnitaryVector n)#: v*n same as f_v*n

template<typename K> Matrix<K> xlifepp::operator*(const Matrix<K> &a, const K &x)#: matrix A * scalar x

template<typename K> Matrix<K> xlifepp::operator*(const Matrix<K> &a, const Matrix<K> &b)#: matrix A * matrix B

template<typename K, typename V> Vector<K> xlifepp::operator*(const Matrix<K> &m, const Vector<V> &v)#: matrix x vector (template)

template<typename K> PolynomialsBasisT<K> xlifepp::operator*(const Matrix<K> &mat, const PolynomialsBasisT<K> &ps)#

template<typename K> std::vector<PolynomialT<K>> xlifepp::operator*(const Matrix<K> &mat, const std::vector<PolynomialT<K>> &ps)#: matrix * [p1,p2, …]

Matrix<complex_t> xlifepp::operator*(const Matrix<real_t> &rA, const complex_t &x)#

multiply real matrix by a complex value

real matrix A * complex x

Matrix<complex_t> xlifepp::operator*(const Matrix<real_t> &rA, const Matrix<complex_t> &cB)#

multiply real matrix by a complex matrix

real matrix A x complex matrix B

Vector<complex_t> xlifepp::operator*(const Matrix<real_t> &rA, const Vector<complex_t> &cV)#

real matrix * complex vector

real matrix x complex vector

OperatorOnFunction &xlifepp::operator*(const Matrix<real_t> &v, UnitaryVector n)#: v*n same as f_v*n

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Matrix<T> &val, const Unknown &un)#: Matrix*u.

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Matrix<T> &val, OperatorOnUnknown &opu)#

MatrixEntry xlifepp::operator*(const MatrixEntry&, const MatrixEntry&)#: product of MatrixEntry

VectorEntry xlifepp::operator*(const MatrixEntry &mat, const VectorEntry &vec)#

matrix * vector (consistent structure)

matrix * vector

template<typename K> PolynomialT<K> xlifepp::operator*(const MonomialT<K> &m, const K &k)#

template<typename K> PolynomialT<K> xlifepp::operator*(const MonomialT<K> &m, const PolynomialT<K> &p)#

template<typename K> MonomialT<K> xlifepp::operator*(const MonomialT<K> &m1, const MonomialT<K> &m2)#

BilinearForm xlifepp::operator*(const number_t&, const BilinearForm&)#: product(left) by an integer scalar

LinearForm xlifepp::operator*(const number_t&, const LinearForm&)#: product(left) by a scalar

complex_t xlifepp::operator*(const number_t n, const complex_t &z)#

Parameter xlifepp::operator*(const number_t v, const Parameter &p)#: product number_t and parameter

OperatorOnUnknown &xlifepp::operator*(const OperatorOnFunction&, const Unknown&)#: op(F)*u

OperatorOnUnknown &xlifepp::operator*(const OperatorOnFunction&, OperatorOnUnknown&)#: product syntax op(F)*Op(u)

KernelOperatorOnUnknowns xlifepp::operator*(const OperatorOnKernel&, const OperatorOnUnknown&)#: opker * opv

KernelOperatorOnTermVector xlifepp::operator*(const OperatorOnKernel &opk, const TermVector &tv)#: opker * tv

KernelOperatorOnUnknowns xlifepp::operator*(const OperatorOnUnknown&, const Kernel&)#: opu * ker

KernelOperatorOnTermVectorAndUnknown xlifepp::operator*(const OperatorOnUnknown&, const KernelOperatorOnTermVectorAndUnknown&)#

KernelOperatorOnUnknowns xlifepp::operator*(const OperatorOnUnknown&, const KernelOperatorOnUnknowns&)#: opu * opker

KernelOperatorOnUnknowns xlifepp::operator*(const OperatorOnUnknown&, const OperatorOnKernel&)#: opu * opker

LcOperatorOnUnknowns xlifepp::operator*(const OperatorOnUnknown &opu, const LcOperatorOnUnknown &lcopv)#

KernelOperatorOnTermVectorAndUnknown xlifepp::operator*(const OperatorOnUnknown &opv, const KernelOperatorOnTermVector &koptv)#

Parameter xlifepp::operator*(const Parameter &p, const complex_t &v)#: product parameter and complex

Parameter xlifepp::operator*(const Parameter &p, const int v)#: product parameter and int

Parameter xlifepp::operator*(const Parameter &p, const int_t v)#: product parameter and int_t

Parameter xlifepp::operator*(const Parameter &p, const number_t v)#: product parameter and number_t

Parameter xlifepp::operator*(const Parameter &p, const real_t v)#: product parameter and real

Parameter xlifepp::operator*(const Parameter &p1, const Parameter &p2)#: product of 2 parameters

Point xlifepp::operator*(const Point&, const real_t)#: scale a point

template<typename K> PolynomialBasisT<K> xlifepp::operator*(const PolynomialBasisT<K> &p, const PolynomialBasisT<K> &q)#

template<typename K> PolynomialsBasisT<K> xlifepp::operator*(const PolynomialBasisT<K> &pb, const std::vector<MonomialT<K>> &vp)#

template<typename K> PolynomialT<K> xlifepp::operator*(const PolynomialT<K> &p, const K &k)#

template<typename K> PolynomialT<K> xlifepp::operator*(const PolynomialT<K> &p, const MonomialT<K> &m)#

template<typename K> PolynomialT<K> xlifepp::operator*(const PolynomialT<K> &p1, const PolynomialT<K> &p2)#

TermVector xlifepp::operator*(const Projector &P, const TermVector &X)#: projection of a TermVector using *

BilinearForm xlifepp::operator*(const real_t&, const BilinearForm&)#: product(left) by a real scalar

LinearForm xlifepp::operator*(const real_t&, const LinearForm&)#: product(left) by a scalar

OperatorOnUnknown &xlifepp::operator*(const real_t&, const Unknown&)#: r*u

LcKernelOperatorOnUnknowns xlifepp::operator*(const real_t &a, const LcKernelOperatorOnUnknowns &lc)#

LcOperatorOnUnknown xlifepp::operator*(const real_t &a, const LcOperatorOnUnknown &lc)#

LcOperatorOnUnknowns xlifepp::operator*(const real_t &a, const LcOperatorOnUnknowns &lc)#

inline SymbolicFunction &xlifepp::operator*(const real_t &r, const SymbolicFunction &f)#

OperatorOnFunction &xlifepp::operator*(const real_t &v, UnitaryVector n)#: v*n same as f_v*n

OperatorOnUnknown &xlifepp::operator*(const real_t &val, OperatorOnUnknown &opu)#

Vector<complex_t> xlifepp::operator*(const real_t &x, const Vector<complex_t> &cA)#: multiply real vector by complex scalar

inline Vector<Matrix<complex_t>> xlifepp::operator*(const real_t &x, const Vector<Matrix<complex_t>> &a)#: scalar x * vector of matrix

template<typename T> inline Vector<Vector<T>> xlifepp::operator*(const real_t &x, const Vector<Vector<T>> &A)#: multiply vector of vector<T> by a real “x * A”

LargeMatrix<complex_t> xlifepp::operator*(const real_t v, const LargeMatrix<complex_t> &mat)#

Parameter xlifepp::operator*(const real_t v, const Parameter &p)#: product real and parameter

Point xlifepp::operator*(const real_t, const Point&)#: scale a point

template<typename K, typename KK> SparseMatrix<K> xlifepp::operator*(const SparseMatrix<K> &a, const KK &x)#: matrix A * scalar x

template<typename K, typename V> Vector<K> xlifepp::operator*(const SparseMatrix<K> &m, const std::vector<V> &v)#: matrix x vector (template)

std::vector<complex_t> xlifepp::operator*(const std::vector<complex_t> &vec, const LargeMatrix<real_t> &mat)#

std::vector<complex_t> xlifepp::operator*(const std::vector<real_t> &vec, const LargeMatrix<complex_t> &mat)#

template<typename T> std::vector<T> xlifepp::operator*(const std::vector<T> &vec, const LargeMatrix<T> &mat)#

template<typename T> std::vector<T> xlifepp::operator*(const std::vector<T> &x, const LowRankMatrix<T> &lrm)#

template<typename K, typename V> Vector<K> xlifepp::operator*(const std::vector<V> &v, const SparseMatrix<K> &m)#: vector x matrix (template)

std::vector<Vector<complex_t>> xlifepp::operator*(const std::vector<Vector<complex_t>> &vec, const LargeMatrix<Matrix<real_t>> &mat)#

std::vector<Vector<complex_t>> xlifepp::operator*(const std::vector<Vector<real_t>> &vec, const LargeMatrix<Matrix<complex_t>> &mat)#

template<typename T> std::vector<Vector<T>> xlifepp::operator*(const std::vector<Vector<T>> &vec, const LargeMatrix<Matrix<T>> &mat)#

SuBilinearForm xlifepp::operator*(const SuBilinearForm&, const complex_t&)#: multiply(right) by a scalar

SuLinearForm xlifepp::operator*(const SuLinearForm &sulf, const complex_t &c)#: product(right) by a scalar

SuTermMatrix xlifepp::operator*(const SuTermMatrix&, const SuTermMatrix&)#: product SuTermMatrix * SuTermMatrix

SuTermVector xlifepp::operator*(const SuTermMatrix &sutM, const SuTermVector &sutV)#

Product of a SuTermMatrix M and a SuTermVector V, the result is a SuTermVector R the columns dof indices of M, say (j1,j2, …jn), may be different from the dof indices of V say (k1,k2, … kp).

product SuTermMatrix * SuTermVector

The dof indices of result vector will be always the lines dof indices of the matrix, say (i1,i2, …im). It means that the product M_i,j * V_j is performed only for j=k.

when {k1,k2, … kp}={j1,j2, …jn} the product is performed using largematrix product
when {k1,k2, … kp} differs from {j1,j2, …jn}, the vector V is extended and reduced to {j1,j2, …jn} and the product is performed using largematrix product

inline SuTermVector xlifepp::operator*(const SuTermVector &s1, const SuTermVector &s2)#

SuTermVector xlifepp::operator*(const SuTermVector &sutV, const SuTermMatrix &sutM)#

Product of a SuTermVector V and a SuTermMatrix M, the result is a SuTermVector R the lines dof indices of M, say (i1,i2, …in), may be different from the dof indices of V say (k1,k2, … kp).

product SuTermVector * SuTermMatrix

The dof indices of result vector will be always the columns dof indices of the matrix, say (j1,j2, …jm). It means that the product V_i * M_i,j is performed only for i=k.

when {k1,k2, … kp}={i1,i2, …in} the product is performed using largematrix product
when {k1,k2, … kp} differs from {i1,i2, …in}, the vector V is extended and reduced to {i1,i2, …in} and the product is performed using largematrix product

exists only for particular storage type

inline SymbolicFunction &xlifepp::operator*(const SymbolicFunction &f, const complex_t &c)#

inline SymbolicFunction &xlifepp::operator*(const SymbolicFunction &f, const real_t &r)#

inline SymbolicFunction &xlifepp::operator*(const SymbolicFunction &f1, const SymbolicFunction &f2)#

TermVector xlifepp::operator*(const SymbolicTermMatrix &S, const TermVector &X)#

template<typename T> LowRankMatrix<T> xlifepp::operator*(const T &s, const LowRankMatrix<T> &L1)#

template<typename T> LcTerm<TermMatrix> xlifepp::operator*(const T &t, const TermMatrix &tv)#: product of TermMatrix by a real or a complex (template T)

template<typename T> LcTerm<TermVector> xlifepp::operator*(const T &t, const TermVector &tv)#

template<typename TT, typename T> LcTerm<TT> xlifepp::operator*(const T &v, const LcTerm<TT> &lc)#

template<typename T> LargeMatrix<T> xlifepp::operator*(const T v, const LargeMatrix<T> &mat)#: Multiple a largeMatrix with a scalar.

TermMatrix xlifepp::operator*(const TermMatrix&, const TermMatrix&)#: product of TermMatrix

TermVector xlifepp::operator*(const TermMatrix&, const TermVector&)#: product TermMatrix * TermVector

SymbolicTermMatrix &xlifepp::operator*(const TermMatrix &M, SymbolicTermMatrix &S)#

TermVector xlifepp::operator*(const TermMatrix &tM, const LcTerm<TermVector> &lctv)#

product TermMatrix * linear combination of TermVector’s

product of a TermMatrix A and a TermVector X There are 2 cases:

TermMatrix has a global representation, say scalar_entries_p !=nullptr or entries_p!=nullptr in that case the product is realized as a standard matrix/vector product Note that TermVector X has to have a global representation consistent with column numbering of TermMatrix if it not the case, global representation of X is computed
TermMatrix has a local representation, say scalar_entries_p =0 and entries_p=0 Assume that A has (v1,v2, …, vm) has row unknowns and (u1,u2, …, un) has column unknowns and X has (p1,p2, …, pq) unknowns where pi may belongs to {u1,u2, …, un} but it is not mandatory the result will be always a (v1,v2, …, vm)-TermVector. Only product of matrix block (vi,uj) with vector block pk=uj will be performed For instance: the product of a (u,v)-Termatrix M with a p-TermVector X is a zero v-TermVector: |Mvu 0vp| * [0u Xp]t = [0v] the product of a [(u,p),(v,q)]-Termatrix M with a p-TermVector X is a (v,q)-TermVector: |Mvu Mvp| |0u| |Mvp*Xp| | | | | = | | |Mqu Mqp| |Xp| |Mqp*Xp| Note that the zero blocks are never created; they are not indexed in the map TermVector::suTerms_ ! The real products are made with SuTermMatrix and SuTermVector

template<typename T> LcTerm<TermMatrix> xlifepp::operator*(const TermMatrix &tv, const T &t)#: product of TermMatrix by a real or a complex (template T)

TermVector xlifepp::operator*(const TermVector&, const TermMatrix&)#: product TermVector * TermMatrix

inline TermVector xlifepp::operator*(const TermVector &s1, const TermVector &s2)#

KernelOperatorOnTermVector xlifepp::operator*(const TermVector &tv, const Kernel &ker)#: tv * ker

KernelOperatorOnTermVector xlifepp::operator*(const TermVector &tv, const OperatorOnKernel &opker)#: tv * opker

template<typename T> LcTerm<TermVector> xlifepp::operator*(const TermVector &tv, const T &t)#: product and division by a real or a complex (template T)

OperatorOnUnknown &xlifepp::operator*(const TermVector &tv, const TestFunction &un)#: tv*u

OperatorOnUnknown &xlifepp::operator*(const TermVector &tv, const Unknown &un)#: tv*u

OperatorOnUnknown &xlifepp::operator*(const TermVector &tv, OperatorOnUnknown &opu)#: tv*opu

TermVector xlifepp::operator*(const TermVector &X, const SymbolicTermMatrix &S)#

OperatorOnUnknown &xlifepp::operator*(const TestFunction &un, const TermVector &tv)#: u*tv

Transformation xlifepp::operator*(const Transformation &t1, const Transformation &t2)#: composition of transformations (general case)

OperatorOnUnknown &xlifepp::operator*(const Unknown&, const complex_t&)#: u*r

OperatorOnUnknown &xlifepp::operator*(const Unknown&, const Function&)#: u*F

KernelOperatorOnUnknowns xlifepp::operator*(const Unknown&, const Kernel&)#: u * ker

KernelOperatorOnUnknowns xlifepp::operator*(const Unknown&, const KernelOperatorOnUnknowns&)#: u * opker

OperatorOnUnknown &xlifepp::operator*(const Unknown&, const OperatorOnFunction&)#: u*op(F)

OperatorOnUnknown &xlifepp::operator*(const Unknown&, const real_t&)#: u*r

OperatorOnUnknown &xlifepp::operator*(const Unknown&, const Value&)#: u*val

OperatorOnUnknown &xlifepp::operator*(const Unknown&, UnitaryVector)#: u*n same as nx(u)

LcOperatorOnUnknowns xlifepp::operator*(const Unknown &u, const LcOperatorOnUnknown &lcopv)#

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Unknown &un, const Matrix<T> &val)#: u*Matrix

OperatorOnUnknown &xlifepp::operator*(const Unknown &un, const TermVector &tv)#: u*tv

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Unknown &un, const Vector<T> &val)#: u*Vector

template<typename T> KernelOperatorOnUnknowns xlifepp::operator*(const Unknown &un, T (*fun)(const Point&, const Point&, Parameters&))#: u * function(Point,Parameters)

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Unknown &un, T (*fun)(const Point&, Parameters&))#: u * function(Point,Parameters)

template<typename T> KernelOperatorOnUnknowns xlifepp::operator*(const Unknown &un, T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&))#: u * function(Vector<Point>,Parameters)

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Unknown &un, T (*fun)(const Vector<Point>&, Parameters&))#: u * function(Vector<Point>,Parameters)

KernelOperatorOnTermVectorAndUnknown xlifepp::operator*(const Unknown &v, const KernelOperatorOnTermVector &koptv)#

OperatorOnUnknown &xlifepp::operator*(const Value&, const Unknown&)#: val*u

OperatorOnUnknown &xlifepp::operator*(const Value&, OperatorOnUnknown&)#: product syntax V*Op(u)

Vector<complex_t> xlifepp::operator*(const Vector<complex_t> &cA, const real_t &x)#

multiply complex vector by real scalar

multiply complex vector by real scalar “A * x”

Vector<complex_t> xlifepp::operator*(const Vector<complex_t> &cV, const Matrix<real_t> &rA)#

complex vector * real matrix

complex vector x real matrix

template<typename K> Vector<K> xlifepp::operator*(const Vector<K> &a, const K &x)#: multiply vector by a scalar “A * x”

template<typename K> Vector<K> xlifepp::operator*(const Vector<K> &a, const Vector<K> &b)#: forbidden product of vector

Vector<complex_t> xlifepp::operator*(const Vector<real_t> &rA, const complex_t &x)#

multiply real vector by complex scalar

multiply real vector by complex scalar “A * x”

Vector<complex_t> xlifepp::operator*(const Vector<real_t> &rV, const Matrix<complex_t> &cA)#

real vector * complex matrix

real vector x complex matrix

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Vector<T> &val, const Unknown &un)#: Vector*u.

template<typename T> OperatorOnUnknown &xlifepp::operator*(const Vector<T> &val, OperatorOnUnknown &opu)#

template<typename K, typename V> Vector<K> xlifepp::operator*(const Vector<V> &v, const Matrix<K> &m)#: vector x matrix (template)

Vector<Vector<complex_t>> xlifepp::operator*(const Vector<Vector<complex_t>>&, const complex_t&)#: multiply complex vector by complex scalar “A * x”

template<typename T> Vector<Vector<T>> xlifepp::operator*(const Vector<Vector<T>> &A, const real_t &x)#: multiply vector of vector<T> by a real “A * x”

template<typename K, typename KK> VectorEigenDense<K> xlifepp::operator*(const VectorEigenDense<K> &vec, const KK &k)#

VectorEntry xlifepp::operator*(const VectorEntry &vec, const MatrixEntry &mat)#

vector * matrix (consistent structure)

vector * matrix

SymbolicTermMatrix &xlifepp::operator*(LcTerm<TermMatrix> &LC, SymbolicTermMatrix &S)#

OperatorOnFunction &xlifepp::operator*(OperatorOnFunction&, UnitaryVector)#: opf*n

OperatorOnKernel &xlifepp::operator*(OperatorOnKernel&, UnitaryVector)#: opker*n

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown&, const Function&)#: product syntax Op(u)*F

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown&, const OperatorOnFunction&)#: product syntax Op(u)*op(F)

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown&, const Value&)#: product syntax Op(u)*V

OperatorOnUnknowns xlifepp::operator*(OperatorOnUnknown&, OperatorOnUnknown&)#: opu * opv

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown&, UnitaryVector)#: div*n same as ndiv(u)

OperatorOnUnknowns xlifepp::operator*(OperatorOnUnknown&, Unknown&)#: opu * v

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, const complex_t &val)#

template<typename T> OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, const Matrix<T> &val)#

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, const real_t &val)#

OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, const TermVector &tv)#: opu*tv

template<typename T> OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, const Vector<T> &val)#

template<typename T> OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, T (*fun)(const Point&, Parameters&))#: opu * function(Point,Parameters)

template<typename T> OperatorOnUnknown &xlifepp::operator*(OperatorOnUnknown &opu, T (*fun)(const Vector<Point>&, Parameters&))#: opu * function(Vector<Point>,Parameters)

inline real_t xlifepp::operator*(real_t a, const AngleUnit &u)#

SymbolicTermMatrix &xlifepp::operator*(SymbolicTermMatrix &S, const complex_t &c)#

SymbolicTermMatrix &xlifepp::operator*(SymbolicTermMatrix &S, const TermMatrix &M)#

SymbolicTermMatrix &xlifepp::operator*(SymbolicTermMatrix &S, LcTerm<TermMatrix> &LC)#

SymbolicTermMatrix &xlifepp::operator*(SymbolicTermMatrix &S1, SymbolicTermMatrix &S2)#

template<typename T> KernelOperatorOnUnknowns xlifepp::operator*(T (*fun)(const Point&, const Point&, Parameters&), const Unknown &un)#: function(Point,Parameters) * u

template<typename T> OperatorOnUnknown &xlifepp::operator*(T (*fun)(const Point&, Parameters&), const Unknown &un)#: function(Point,Parameters) * u

template<typename T> OperatorOnUnknown &xlifepp::operator*(T (*fun)(const Point&, Parameters&), OperatorOnUnknown &opu)#: function(Point,Parameters) * opu

template<typename T> KernelOperatorOnUnknowns xlifepp::operator*(T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&), const Unknown &un)#: function(Vector<Point>,Parameters) * u

template<typename T> OperatorOnUnknown &xlifepp::operator*(T (*fun)(const Vector<Point>&, Parameters&), const Unknown &un)#: function(Vector<Point>,Parameters) * u

template<typename T> OperatorOnUnknown &xlifepp::operator*(T (*fun)(const Vector<Point>&, Parameters&), OperatorOnUnknown &opu)#: function(Vector<Point>,Parameters) * opu

OperatorOnFunction &xlifepp::operator*(UnitaryVector n, const complex_t &v)#

v*n same as f_v*n

n*v same as n*f_v

OperatorOnFunction &xlifepp::operator*(UnitaryVector n, const Matrix<complex_t> &v)#

v*n same as f_v*n

n*v same as n*f_v

OperatorOnFunction &xlifepp::operator*(UnitaryVector n, const Matrix<real_t> &v)#

v*n same as f_v*n

n*v same as n*f_v

OperatorOnFunction &xlifepp::operator*(UnitaryVector n, const real_t &v)#

v*n same as f_v*n

n*v same as n*f_v

OperatorOnFunction &xlifepp::operator*(UnitaryVector, const Function&)#: n*f same as ntimes(f)/ncrossntimes(f)

OperatorOnKernel &xlifepp::operator*(UnitaryVector, const Kernel&)#: n*ker same as ntimes(ker)

OperatorOnUnknown &xlifepp::operator*(UnitaryVector, const Unknown&)#: n*u same as nx(u)

OperatorOnFunction &xlifepp::operator*(UnitaryVector, OperatorOnFunction&)#: n*opf

OperatorOnKernel &xlifepp::operator*(UnitaryVector, OperatorOnKernel&)#: n*opker

OperatorOnUnknown &xlifepp::operator*(UnitaryVector, OperatorOnUnknown&)#: n*div same as ndiv(u)

OperatorOnUnknowns xlifepp::operator*(Unknown&, OperatorOnUnknown&)#: u * opv

OperatorOnUnknowns xlifepp::operator*(Unknown&, Unknown&)#: u * v