operator+#

const BilinearForm &xlifepp::operator+(const BilinearForm&)#: same bilinear form

BilinearForm xlifepp::operator+(const BilinearForm&, const BilinearForm&)#: sum of bilinear forms

Parameter xlifepp::operator+(const char *v, const Parameter &p)#: add char* and parameter

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

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

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

add a complex scalar to a real matrix

complex x + real matrix A

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

add a scalar to vector

add complex scalar to real vector

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)#

GeomDomain &xlifepp::operator+(const GeomDomain &dom1, const GeomDomain &dom2)#

< create the domain made of union of elements (same dimension)

create the domain made of union of elements (same dimension)

Geometry xlifepp::operator+(const Geometry &g1, const Geometry &g2)#: union of g1 and g2 (general case)

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

Parameter xlifepp::operator+(const int v, const Parameter &p)#: add int and parameter

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

Parameter xlifepp::operator+(const int_t v, const Parameter &p)#: add int_t and parameter

template<typename K> Vector<K> xlifepp::operator+(const K &x, const Vector<K> &a)#: add a scalar to a vect or “x+A”

LcKernelOperatorOnUnknowns xlifepp::operator+(const KernelOperatorOnUnknowns &opkuv, const LcKernelOperatorOnUnknowns &lc)#

LcKernelOperatorOnUnknowns xlifepp::operator+(const KernelOperatorOnUnknowns &opkuv1, const KernelOperatorOnUnknowns &opkuv2)#

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> &matA, const LargeMatrix<real_t> &matB)#

LargeMatrix<complex_t> xlifepp::operator+(const LargeMatrix<real_t> &matA, const LargeMatrix<complex_t> &matB)#

template<typename T> LargeMatrix<T> xlifepp::operator+(const LargeMatrix<T> &matA, const LargeMatrix<T> &matB)#

LcKernelOperatorOnUnknowns xlifepp::operator+(const LcKernelOperatorOnUnknowns&)#: algebraic operations

LcKernelOperatorOnUnknowns xlifepp::operator+(const LcKernelOperatorOnUnknowns &lc, const KernelOperatorOnUnknowns &opkuv)#

LcKernelOperatorOnUnknowns xlifepp::operator+(const LcKernelOperatorOnUnknowns &lc1, const LcKernelOperatorOnUnknowns &lc2)#

LcOperatorOnUnknown xlifepp::operator+(const LcOperatorOnUnknown&)#: algebraic operations

LcOperatorOnUnknown xlifepp::operator+(const LcOperatorOnUnknown &lc, const OperatorOnUnknown &opu)#

LcOperatorOnUnknown xlifepp::operator+(const LcOperatorOnUnknown &lc, const Unknown &u)#

LcOperatorOnUnknown xlifepp::operator+(const LcOperatorOnUnknown &lc1, const LcOperatorOnUnknown &lc2)#

LcOperatorOnUnknowns xlifepp::operator+(const LcOperatorOnUnknowns &lc)#

LcOperatorOnUnknowns xlifepp::operator+(const LcOperatorOnUnknowns &lc, const OperatorOnUnknowns &opus)#

LcOperatorOnUnknowns xlifepp::operator+(const LcOperatorOnUnknowns &lc1, const LcOperatorOnUnknowns &lc2)#

LcTerm<TermMatrix> xlifepp::operator+(const LcTerm<TermMatrix>&, const TermMatrix&)#: addition of a TermMatrix to a LcTerm

LcTerm<TermVector> xlifepp::operator+(const LcTerm<TermVector> &lctv, const TermVector &tv)#

template<typename TT> LcTerm<TT> xlifepp::operator+(const LcTerm<TT> &cl)#

template<typename TT> LcTerm<TT> xlifepp::operator+(const LcTerm<TT> &cl1, const LcTerm<TT> &cl2)#

LinearForm xlifepp::operator+(const LinearForm&, const LinearForm&)#: sum of linear forms

template<typename T> LowRankMatrix<T> xlifepp::operator+(const LowRankMatrix<T> &L1)#

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

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

add a real matrix and a complex matrix

complex matrix A + real matrix B

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

template<typename K> Matrix<K> xlifepp::operator+(const Matrix<K> &a, const Matrix<K> &b)#: sum of two matrices

template<typename K> Matrix<K> xlifepp::operator+(const Matrix<K> &m)#: unary operator+

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

add a complex scalar to a real matrix

real matrix A + complex x

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

add a complex matrix and a real matrix

real matrix A + complex matrix B

inline Mesh xlifepp::operator+(const Mesh &m1, const Mesh &m2)#

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

Parameter xlifepp::operator+(const number_t v, const Parameter &p)#: add number_t and parameter

LcOperatorOnUnknown xlifepp::operator+(const OperatorOnUnknown &opu, const LcOperatorOnUnknown &lc)#

LcOperatorOnUnknown xlifepp::operator+(const OperatorOnUnknown &opu, const OperatorOnUnknown &opv)#

LcOperatorOnUnknown xlifepp::operator+(const OperatorOnUnknown &opu, const Unknown &v)#

LcOperatorOnUnknowns xlifepp::operator+(const OperatorOnUnknowns&, const OperatorOnUnknowns&)#: algebraic operations

LcOperatorOnUnknowns xlifepp::operator+(const OperatorOnUnknowns &opus, const LcOperatorOnUnknowns &lc)#

Parameter xlifepp::operator+(const Parameter &p, const char *v)#: add parameter and char*

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

Parameter xlifepp::operator+(const Parameter &p, const int v)#: add parameter and int

Parameter xlifepp::operator+(const Parameter &p, const int_t v)#: add parameter and int_t

Parameter xlifepp::operator+(const Parameter &p, const number_t v)#: add parameter and number_t

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

Parameter xlifepp::operator+(const Parameter &p, const string_t &v)#: add parameter and string

Parameter xlifepp::operator+(const Parameter &p1, const Parameter &p2)#: add 2 parameters

Point xlifepp::operator+(const Point&)#: same point (completeness)

Point xlifepp::operator+(const Point&, const Point&)#: sum of two points

Point xlifepp::operator+(const Point&, const real_t)#: sum of two points

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

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

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

add a scalar to vector

add real scalar to complex vector

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

Point xlifepp::operator+(const real_t, const Point&)#: sum of two points

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

template<typename K, typename KK> SparseMatrix<K> xlifepp::operator+(const SparseMatrix<K> &a, const SparseMatrix<KK> &b)#: sum of two matrices

template<typename K> SparseMatrix<K> xlifepp::operator+(const SparseMatrix<K> &m)#: unary operator+

Parameter xlifepp::operator+(const string_t &v, const Parameter &p)#: add string and parameter

SuBilinearForm xlifepp::operator+(const SuBilinearForm&, const SuBilinearForm&)#: sum of bilinear forms

SuLinearForm xlifepp::operator+(const SuLinearForm &sulf1, const SuLinearForm &sulf2)#: sum of linear forms

inline SuTermVector xlifepp::operator+(const SuTermVector &s)#

inline SuTermVector xlifepp::operator+(const SuTermVector &s1, const SuTermVector &s2)#: binary and unary operators applied to SuTermVector’s, assuming they have the same size

inline SymbolicFunction &xlifepp::operator+(const SymbolicFunction &f)#

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)#

const TermMatrix &xlifepp::operator+(const TermMatrix&)#: unary operator+

LcTerm<TermMatrix> xlifepp::operator+(const TermMatrix&, const LcTerm<TermMatrix>&)#: addition of a TermMatrix to a LcTerm

LcTerm<TermMatrix> xlifepp::operator+(const TermMatrix&, const TermMatrix&)#: addition of TermMatrix

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

const TermVector &xlifepp::operator+(const TermVector &tv)#

multiple algebraic operations on TermVector produce a LcTerm object (linear combination of terms) the computation is done by constructor from LcTerm or assign operation of a LcTerm

addition of TermVector

LcTerm<TermVector> xlifepp::operator+(const TermVector &tv, const LcTerm<TermVector> &lctv)#

LcTerm<TermVector> xlifepp::operator+(const TermVector &tv1, const TermVector &tv2)#

LcOperatorOnUnknown xlifepp::operator+(const Unknown &u, const LcOperatorOnUnknown &lc)#

LcOperatorOnUnknown xlifepp::operator+(const Unknown &u, const OperatorOnUnknown &opv)#

LcOperatorOnUnknown xlifepp::operator+(const Unknown &u, const Unknown &v)#

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

add a scalar to vector

add real scalar to complex vector

Vector<complex_t> xlifepp::operator+(const Vector<complex_t> &cA, const Vector<real_t> &rB)#

vector addition

vector addition “ complex A + real B”

template<typename K> Vector<K> xlifepp::operator+(const Vector<K> &a)#: unary + (return same vector)

template<typename K> Vector<K> xlifepp::operator+(const Vector<K> &a, const K &x)#: add a scalar to a vector “A+x”

template<typename K> Vector<K> xlifepp::operator+(const Vector<K> &a, const Vector<K> &b)#: add two vectors

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

add a scalar to vector

add complex scalar to real vector

Vector<complex_t> xlifepp::operator+(const Vector<real_t> &rA, const Vector<complex_t> &cB)#

vector addition

vector addition “ real A + complex B”

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

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

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

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