xlifepp – Functions

abs

template<typename K>
inline Matrix<real_t> xlifepp::abs(const Matrix<K> &mat)

abs of a matrix

template<typename K>
inline Matrix<Matrix<real_t>> xlifepp::abs(const Matrix<Matrix<K>> &mat)

abs of a matrix of matrices

template<typename K>
inline SparseMatrix<real_t> xlifepp::abs(const SparseMatrix<K> &mat)

abs of a matrix

inline SuTermVector xlifepp::abs(const SuTermVector &s)

inline SymbolicFunction &xlifepp::abs(const SymbolicFunction &f)

TermVector xlifepp::abs(const TermVector &tv)

extracts modulus

Vector<real_t> xlifepp::abs(const Vector<complex_t> &a)

abs of a complex vector

Vector<real_t> xlifepp::abs(const Vector<real_t> &a)

abs of a real vector

Vector<Vector<real_t>> xlifepp::abs(const Vector<Vector<complex_t>> &a)

abs of a vector of complex vectors

Vector<Vector<real_t>> xlifepp::abs(const Vector<Vector<real_t>> &a)

abs of a vector of real vectors

absTpl

template<typename T1_iterator, typename R_iterator>
void xlifepp::absTpl(T1_iterator b1, T1_iterator e1, R_iterator Rb)

returns magnitude of vector entries: R[i] = abs(T1[i])

acaFullMethod

template<typename T, typename K>
void xlifepp::acaFullMethod(const SuBilinearForm &subf, LowRankMatrix<T> &lrm, number_t rmax, real_t eps, const std::vector<number_t> &rowDofs, const std::vector<number_t> &colDofs, const std::vector<Element*> &rowElts, const std::vector<Element*> &colElts, IEcomputationParameters &ieparams, K &vt, const std::list<std::multimap<real_t, IntgMeth>> &intgMaps, const std::vector<KernelOperatorOnUnknowns*> &kopregs, const std::vector<KernelOperatorOnUnknowns*> &kopsings, const std::map<Element*, GeoNumPair> &sidelts_u, const std::map<Element*, GeoNumPair> &sidelts_v, bool noUpdatedNormal, bool same_interpolation, bool sym)

compute Low Rank Matrix using ACA full pivoting method algorithm from the phd thesis of Benoît Lizé

T: type of the matrix coefficient K: type of computation (real or complex)

subf: a single unknown bilinear form defined on a unique domains pair (assumed) vt: to pass as template the scalar type (real or complex) lrm: the LowRankMatrix to build rmax: maximum rank of low rank matrix (if 0, not used) eps: threshold of low rank matrix: |A-Ar|< eps*|A| rowDofs, colDofs: row and col dofs involved rowElts, colElts: row/col elements supporting row/col dofs ieparams: useful informations on ie computation intgMaps: list of integration methods to be used (built outside) kopregs , kopsings: list of regular and singular kernels when required

Produce a low rank matrix of the form A*B’ with A of size m x k and B of size n x k, k the rank

acaPartialMethod

template<typename T, typename K>
void xlifepp::acaPartialMethod(const SuBilinearForm &subf, LowRankMatrix<T> &lrm, number_t rmax, real_t eps, const std::vector<number_t> &rowDofs, const std::vector<number_t> &colDofs, const std::vector<Element*> &rowElts, const std::vector<Element*> &colElts, const Space *rowSpace, const Space *colSpace, IEcomputationParameters &ieparams, K &vt, const std::list<std::multimap<real_t, IntgMeth>> &intgMaps, const std::vector<KernelOperatorOnUnknowns*> &kopregs, const std::vector<KernelOperatorOnUnknowns*> &kopsings, const std::map<Element*, GeoNumPair> &sidelts_u, const std::map<Element*, GeoNumPair> &sidelts_v, bool noUpdatedNormal, bool same_interpolation, bool sym)

compute Low Rank Matrix using ACA partial pivoting method algorithm from the phd thesis of Benoît Lizé

T: type of the matrix coefficient K: type of computation (real or complex)

subf: a single unknown bilinear form defined on a unique domains pair (assumed) vt: to pass as template the scalar type (real or complex) mat: the LowRankMatrix to build rowDofs, colDofs: row and col dofs involved (start at 0) rowElts, colElts: pointers to row/col element supporting row/col dofs rowSpace, colSpace: row/col spaces (required to get FeDof) ieparams: useful informations on ie computation intgMaps: list of integration methods to be used (built outside) kopregs , kopsings: list of regular and singular kernels when required

Produce a low rank matrix of the form A*I*B

acaPlusMethod

template<typename T, typename K>
void xlifepp::acaPlusMethod(const SuBilinearForm &subf, LowRankMatrix<T> &lrm, number_t rmax, real_t eps, const std::vector<number_t> &rowDofs, const std::vector<number_t> &colDofs, const std::vector<Element*> &rowElts, const std::vector<Element*> &colElts, const Space *rowSpace, const Space *colSpace, IEcomputationParameters &ieparams, K &vt, const std::list<std::multimap<real_t, IntgMeth>> &intgMaps, const std::vector<KernelOperatorOnUnknowns*> &kopregs, const std::vector<KernelOperatorOnUnknowns*> &kopsings, const std::map<Element*, GeoNumPair> &sidelts_u, const std::map<Element*, GeoNumPair> &sidelts_v, bool noUpdatedNormal, bool same_interpolation, bool sym)

compute Low Rank Matrix using ACA plus partial pivoting method algorithm from the phd thesis of Benoît Lizé

T: type of the matrix coefficient K: type of computation (real or complex)

subf: a single unknown bilinear form defined on a unique domains pair (assumed) vt: to pass as template the scalar type (real or complex) mat: the LowRankMatrix to build rowDofs, colDofs: row and col dofs involved (start at 0) rowElts, colElts: pointers to row/col element supporting row/col dofs rowSpace, colSpace: row/col spaces (required to get FeDof) ieparams: useful informations on ie computation intgMaps: list of integration methods to be used (built outside) kopregs , kopsings: list of regular and singular kernels when required

Produce a low rank matrix of the form A*I*B

acos

complex_t xlifepp::acos(const complex_t &z)

inline SuTermVector xlifepp::acos(const SuTermVector &s)

inline SymbolicFunction &xlifepp::acos(const SymbolicFunction &f)

inline TermVector xlifepp::acos(const TermVector &s)

acosh

complex_t xlifepp::acosh(const complex_t &z)

real_t xlifepp::acosh(const real_t &r)

inline SuTermVector xlifepp::acosh(const SuTermVector &s)

inline SymbolicFunction &xlifepp::acosh(const SymbolicFunction &f)

inline TermVector xlifepp::acosh(const TermVector &s)

adaptiveTrapz

template<typename T>
T xlifepp::adaptiveTrapz(T (*f)(real_t), real_t a, real_t b, real_t eps = 1E-6)

template<typename T>
T xlifepp::adaptiveTrapz(T (*f)(real_t, Parameters&), Parameters &pars, real_t a, real_t b, real_t eps = 1E-6)

add

TermVector xlifepp::add(const TermVector&, const TermVector&)

create TermVector U+V evaluate dofs on a function: dof_i(f) for any scalar dofs related to scalar unknown u and domain

addCanonicalAndCanonical

void xlifepp::addCanonicalAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)

addCompositeAndCanonical

void xlifepp::addCompositeAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)

addCompositeAndComposite

void xlifepp::addCompositeAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)

addCompositeAndLoop

void xlifepp::addCompositeAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)

addDualRhs

void xlifepp::addDualRhs(const TermMatrix&, TermVector&)

add rhs of constraints on multipliers (dual reduction, internal tool)

addElts

void xlifepp::addElts(Node<GeomElement> *node, std::set<GeomElement*> &elts, const std::set<number_t> &vns, std::map<string_t, std::pair<GeomElement*, GeomElement*>> &sideIndex, std::set<number_t> vBoundaryIndex, std::map<string_t, GeomElement*> &cdomIndex, dimen_t d)

void xlifepp::addElts(std::set<GeomElement*> &elts, std::set<GeomElement*> &elts1, std::set<GeomElement*> &elts2, const std::set<number_t> &vSideCrack)

addLine

template<typename T>
static bool xlifepp::addLine(std::vector<T> &val, const MatrixStorage &sto, const std::vector<std::pair<number_t, number_t>> &line, number_t t, bool byCol, const T &a)

linear combination of a line of matrix values: val[pos(r,t)] += a*val[adr] (byCol) or val[pos(t,c)] += a*val[adr] for the coefficients (r or c, adr) of the line, t the index of the target line; returns false if a coefficient has no position in the target line (storage not updated)

addLoopAndCanonical

void xlifepp::addLoopAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)

addLoopAndLoop

void xlifepp::addLoopAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)

addMatrixMatrix

void xlifepp::addMatrixMatrix(const LargeMatrix<complex_t> &matA, const LargeMatrix<real_t> &matB, LargeMatrix<complex_t> &matC)

Add two different type largeMatrix and store result into the third The two matrices must share the same storage.

The result matrix will point to the same storage after the summation

Parameters:

• matA – complex matrix

• matB – real matrix

• matC – complex matrix which share the same storage.

void xlifepp::addMatrixMatrix(const LargeMatrix<real_t> &matA, const LargeMatrix<complex_t> &matB, LargeMatrix<complex_t> &matC)

Add two different type largeMatrix and store result into the third The two matrices must share the same storage.

The result matrix will point to the same storage after the summation

Parameters:

• matA – real matrix

• matB – complex matrix

• matC – complex matrix which share the same storage.

template<typename T>
void xlifepp::addMatrixMatrix(const LargeMatrix<T> &matA, const LargeMatrix<T> &matB, LargeMatrix<T> &matC)

template<typename T>
LargeMatrix<T> xlifepp::addMatrixMatrix(const LargeMatrix<T> &matA, const LargeMatrix<T> &matB, T s = T(1))

A+s*B.

addMatrixMatrixSkyline

template<typename S>
LargeMatrix<S> *xlifepp::addMatrixMatrixSkyline(const LargeMatrix<S> &matA, const LargeMatrix<S> &matB)

template<typename T>
LargeMatrix<T> *xlifepp::addMatrixMatrixSkyline(const LargeMatrix<T> &matA, const LargeMatrix<T> &matB)

addScaledVector

template<typename T>
void xlifepp::addScaledVector(SuTermVector &x, SuTermVector &v, const T &t)

special operation to accumulate t*v in x, assumed consistent unknown and same size

x+=v*t

template<typename T>
void xlifepp::addScaledVector(TermVector &x, TermVector &v, const T &t)

x+=t*v

void xlifepp::addScaledVector(VectorEntry&, VectorEntry&, const complex_t&)

x+=t*v (t complex)

void xlifepp::addScaledVector(VectorEntry&, VectorEntry&, const real_t&)

x+=t*v (t real)

addVectorThenAssign

void xlifepp::addVectorThenAssign(TermVector &tv1, const TermVector &tv2)

function used in solver

operation U+=t

template<typename K, typename KK>
void xlifepp::addVectorThenAssign(Vector<K> &v, const Vector<KK> &b)

void xlifepp::addVectorThenAssign(Vector<real_t> &v, const Vector<complex_t> &cA)

Add then assign complex_t to real_t In fact, this kind of function is forbidden but we implement it here as a trick to overcome the problem of instantiation in Solver.

adj

inline complex_t xlifepp::adj(const complex_t&)

Matrix<complex_t> xlifepp::adj(const Matrix<complex_t> &cB)

adjoint of a complex matrix

adjoint complex matrix

Matrix<real_t> xlifepp::adj(const Matrix<real_t> &rB)

adjoint of a real matrix (transpose)

adjoint (transpose) real matrix

inline real_t xlifepp::adj(const real_t&)

template<typename T>
Value &xlifepp::adj(const T &v)

OperatorOnFunction &xlifepp::adj(Function&)

conjugate and transpose f

OperatorOnKernel &xlifepp::adj(Kernel&)

conjugate and transpose k

OperatorOnFunction &xlifepp::adj(OperatorOnFunction&)

conjugate and transpose opf

OperatorOnKernel &xlifepp::adj(OperatorOnKernel&)

conjugate and transpose opk

SymbolicTermMatrix &xlifepp::adj(SymbolicTermMatrix &S)

template<typename T>
inline Function &xlifepp::adj(T (*fun)(const Point&, const Point&, Parameters&))

template<typename T>
inline Function &xlifepp::adj(T (*fun)(const Point&, Parameters&))

template<typename T>
inline Function &xlifepp::adj(T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&))

template<typename T>
inline Function &xlifepp::adj(T (*fun)(const Vector<Point>&, Parameters&))

Value &xlifepp::adj(Value &v)

set to true or false the temporary conjugate/transpose flag

set to true or false the temporary transpose/conjugate flag

adjoint

inline complex_t xlifepp::adjoint(const complex_t &c)

template<typename M_it, typename MM_it>
void xlifepp::adjoint(const dimen_t nbr, const dimen_t nbc, M_it it_m1b, MM_it it_m2b)

Matrix<complex_t> xlifepp::adjoint(const Matrix<complex_t> &cB)

adjoint of a complex matrix

adjoint complex matrix

Matrix<real_t> xlifepp::adjoint(const Matrix<real_t> &rB)

adjoint of a real matrix (transpose)

adjoint (transpose) real matrix

template<typename K>
MatrixEigenDense<K> xlifepp::adjoint(const MatrixEigenDense<K> &mat)

inline real_t xlifepp::adjoint(const real_t &r)

template<typename K>
SparseMatrix<K> xlifepp::adjoint(const SparseMatrix<K> &m)

adjointVec

template<typename K>
VectorEigenDense<K> xlifepp::adjointVec(const VectorEigenDense<K> &v)

Adjoint a vector.

Parameters:

v – [in] source vector

Returns:

adjointed vector

adjustScalarEntriesG

void xlifepp::adjustScalarEntriesG(VectorEntry *&scalar_entries_p, std::vector<DofComponent> &cdofs, const std::vector<DofComponent> &newcdofs)

adjust the scalar entries to the cdofs numbering newcdofs when cdofs is included in newcdofs, new zeros are introduced (extension) when newcdofs is included in cdofs , coefficients are removed (restriction) else it is in a same time a restriction (removed cdofs) and an extension (omitted cdof) in any case, the coefficient may be permuted and cdofs = newcdofs at the end

tool to adjust VectorEntry

used by SuTermVector and TermVector

adjustSuTermVector

void xlifepp::adjustSuTermVector(SuTermVector *sv, const std::vector<DofComponent> &ncdofs)

airy

inline complex_t xlifepp::airy(const complex_t &z, DiffOpType d = _id)

Airy function: Ai(z) or Ai’(z)

inline complex_t xlifepp::airy(real_t x, DiffOpType d = _id)

Airy function: Ai(x) or Ai’(x)

airyError

void xlifepp::airyError(int err, const complex_t &z, const string_t &pr)

airyR

inline real_t xlifepp::airyR(const real_t &x)

airyRp

inline real_t xlifepp::airyRp(const real_t &x)

airyRpp

inline real_t xlifepp::airyRpp(const real_t &x)

alignTermMatrix

void xlifepp::alignTermMatrix(TermMatrix*&, TermMatrix*&, bool keepMatrix = true)

check if same dofs and align Termatrix’s if not the same dofs (internal tool)

check if A and B are defined on the same dofs, if not, align matrix to the largest set of dofs (union of A dofs and B dofs) use the sums A+0*diag(B) and B+0*diag(A) to produced matrices with same dofs if keepMatrix = true, create copy of A, B matrices on the memory stack if keepMatrix = false, A, B matrices are modified if not the same dofs NOTE: adding diagonal 0 induces storage change and may increase significatively the storage size !

allocAsB

template<class MAB_, class MAsB_>
MAsB_ *xlifepp::allocAsB(const MAB_ &matA, const MAB_ &matB, const complex_t sigma)

template<class K_, class MAsB_, class MB_>
MAsB_ *xlifepp::allocAsB(const MAsB_ &matA, const MB_ &matB, const K_ sigma)

Allocation of temporary matrix A - s B.

allocAsI

template<class K_, class MA_>
MA_ *xlifepp::allocAsI(const MA_ &matA, const K_ sigma)

Allocation of temporary matrix A - s Id.

alternateRule

void xlifepp::alternateRule(QuadRule, ShapeType, const string_t&)

display message before choosing an alternate rule

angle

inline real_t xlifepp::angle(const std::vector<real_t> &u, const std::vector<real_t> &v, const std::vector<real_t> &n = std::vector<real_t>())

signed or unsigned angle u to v in [-pi,pi], n unit normal to u-v plane in 2D and 3D; |n|=1 and n^(u^v) = 0 are not checked ! sign of angle is related to n, if n is not given, n=u^v is chosen and thus angle is always >=0 (not signed) if u=0 or v=0 it returns 0

appliedRhsCorrectorTo

void xlifepp::appliedRhsCorrectorTo(VectorEntry *b, const std::vector<DofComponent> &cdofsb, MatrixEntry *rhsmat, const Constraints *cu, const Constraints *cv, const ReductionMethod &rm)

correct a right hand side b to take into account constraints recall that constraints on unknown are of the form Ue1 + CUr1 = f (C matrix e1 x r1) and constraints on test functions are of the form Ve2 + DVr2 = 0 (D matrix e2 x r2) where ei stands for eliminated indices and ri for reduced indices (e1=e2 and r1=r2 in most cases) in the matrix reduction process, a corrector matrix has been computed, say E matrix m x e1 the correction process consists in first step : b -= E * f_e1 (column combination) second step: b_r2 -= Dt * b_e2 (row combination) third step : b_e2 = f_e1 (deletion in case of real reduction) in simple cases (Dirichlet for instance), C=D=0 so the second step is not required

right hand side constraints correction

b : scalar vector to be corrected cdofsb: component dof of vector b rhsmap: pointer to correction matrix (C) cu, cv: pointer to u/v constraints system

applyEssentialConditions

void xlifepp::applyEssentialConditions(VectorEntry &v, const std::vector<DofComponent> &cdofs, const Constraints &cs)

apply essential condition to a VectorEntry (user tool) v : the SCALAR vector to be reduced cdofs: the component dofs of the vector v cs : the constraints to apply once reduced, the constraints reads Ve = f - C*Vr where Ve the ne eliminated components, Vr the nr reduced components and C a ne x nr matrix this function, first build the vector s = f - C*Vr and then set the eliminated components of v to s

apply constraints to a vector

arConvergedEigenvalues

int xlifepp::arConvergedEigenvalues()

arEigInfos

std::string xlifepp::arEigInfos()

This function calls the previous ones, gather the informations in a string which is returned.

areNeighbors2D

bool xlifepp::areNeighbors2D(const Point &p, const Point &q, real_t tol)

determines if a prism is valid

determines if 2D points are neighbors

areNeighbors3D

bool xlifepp::areNeighbors3D(const Point &p, const Point &q, real_t tol)

determines if 3D points are neighbors

arePointsCoplanar

bool xlifepp::arePointsCoplanar(const Point &p1, const Point &p2, const Point &p3, const Point &p4, real_t tol)

test if 4 points are coplanar

bool xlifepp::arePointsCoplanar(const std::vector<Point> &p, real_t tol)

test if a set of points is coplanar

arGetAutoShift

bool xlifepp::arGetAutoShift()

arGetIter

int xlifepp::arGetIter()

arGetMaxit

int xlifepp::arGetMaxit()

arGetMode

int xlifepp::arGetMode()

arGetModeStr

std::string xlifepp::arGetModeStr()

arGetN

int xlifepp::arGetN()

arGetNcv

int xlifepp::arGetNcv()

arGetNev

int xlifepp::arGetNev()

arGetShift

std::complex<double> xlifepp::arGetShift()

arGetShiftImag

double xlifepp::arGetShiftImag()

arGetTol

double xlifepp::arGetTol()

arGetWhich

std::string xlifepp::arGetWhich()

Argyris2dMap

void xlifepp::Argyris2dMap(const std::vector<real_t> &rw, std::vector<real_t> &w, real_t j11, real_t j12, real_t j21, real_t j22, real_t t11, real_t t12, real_t t13, real_t t21, real_t t22, real_t t23, real_t t31, real_t t32, real_t t33, real_t a1, real_t a2, real_t a3, real_t b1, real_t b2, real_t b3, real_t c1, real_t c2, real_t c3, real_t d1, real_t d2, real_t d3, real_t n1x, real_t n1y, real_t n2x, real_t n2y, real_t n3x, real_t n3y)

arInterfaceObj

std::string xlifepp::arInterfaceObj()

arKindOfFactorization

std::string xlifepp::arKindOfFactorization()

arpackObj

std::string xlifepp::arpackObj()

arpackSolve

EigenElements xlifepp::arpackSolve(TermMatrix *A, TermMatrix *B, const std::vector<Parameter> &ps)

Main entry point for Arpack eigenvalue solver.

arParametersDefined

bool xlifepp::arParametersDefined()

array2Vector

template<typename K_>
void xlifepp::array2Vector(const K_ *source, std::vector<K_> &vec)

Convert array of K_ to vector.

ascendingSeriesOfE1

complex_t xlifepp::ascendingSeriesOfE1(const complex_t &z)

ascending series in E1 formula (used for ‘small’ z)

asin

complex_t xlifepp::asin(const complex_t &z)

inline SuTermVector xlifepp::asin(const SuTermVector &s)

inline SymbolicFunction &xlifepp::asin(const SymbolicFunction &f)

inline TermVector xlifepp::asin(const TermVector &s)

asinh

complex_t xlifepp::asinh(const complex_t &z)

real_t xlifepp::asinh(const real_t &r)

inline SuTermVector xlifepp::asinh(const SuTermVector &s)

inline SymbolicFunction &xlifepp::asinh(const SymbolicFunction &f)

inline TermVector xlifepp::asinh(const TermVector &s)

assemblyDG

template<typename T, typename K>
void xlifepp::assemblyDG(LargeMatrix<T> &mat, std::vector<Matrix<K>> &matels, const K &coef, bool onlyM11, const std::vector<number_t> &adrs11, const std::vector<number_t> &adrs12, const std::vector<number_t> &adrs21, const std::vector<number_t> &adrs22, bool sym, const std::vector<number_t> &dofNum_u1, const std::vector<number_t> &dofNum_v1, number_t ncu1, number_t ncv1, const std::vector<number_t> &dofNum_u2, const std::vector<number_t> &dofNum_v2, number_t ncu2, number_t ncv2)

assemblyMat

inline void xlifepp::assemblyMat(complex_t &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMat(complex_t &mat, Matrix<real_t>::iterator itM, number_t nbu)

template<typename K, typename IteratorM>
inline void xlifepp::assemblyMat(K &mat, IteratorM itM, number_t nbu)

inline void xlifepp::assemblyMat(Matrix<complex_t> &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMat(Matrix<complex_t> &mat, Matrix<real_t>::iterator itM, number_t nbu)

template<typename K, typename IteratorM>
inline void xlifepp::assemblyMat(Matrix<K> &mat, IteratorM itM, number_t nbu)

inline void xlifepp::assemblyMat(Matrix<real_t> &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMat(Matrix<real_t> &mat, Matrix<real_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMat(real_t &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMat(real_t &mat, Matrix<real_t>::iterator itM, number_t nbu)

assemblyMatNoCritical

inline void xlifepp::assemblyMatNoCritical(complex_t &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(complex_t &mat, Matrix<real_t>::iterator itM, number_t nbu)

template<typename K, typename IteratorM>
inline void xlifepp::assemblyMatNoCritical(K &mat, IteratorM itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(Matrix<complex_t> &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(Matrix<complex_t> &mat, Matrix<real_t>::iterator itM, number_t nbu)

template<typename K, typename IteratorM>
inline void xlifepp::assemblyMatNoCritical(Matrix<K> &mat, IteratorM itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(Matrix<real_t> &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(Matrix<real_t> &mat, Matrix<real_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(real_t &mat, Matrix<complex_t>::iterator itM, number_t nbu)

inline void xlifepp::assemblyMatNoCritical(real_t &mat, Matrix<real_t>::iterator itM, number_t nbu)

assign

inline void xlifepp::assign(complex_t &x, const complex_t &y)

inline void xlifepp::assign(complex_t &x, const real_t &y)

inline void xlifepp::assign(real_t &x, const complex_t &y)

inline void xlifepp::assign(real_t &x, const real_t &y)

Assigns y to x for all combinations of a priori unknown types of x and y thus preventing from an invalid cast.

assignVectorTo

template<>
inline void xlifepp::assignVectorTo(complex_t &t, const complex_t &v)

template<>
inline void xlifepp::assignVectorTo(complex_t &t, const real_t &v)

template<>
inline void xlifepp::assignVectorTo(real_t &t, const real_t &v)

template<typename T, typename K>
inline void xlifepp::assignVectorTo(T &t, const K &v)

some fake functions to override template compilation problem of OperatorOnFunction::eval

template<>
inline void xlifepp::assignVectorTo(Vector<complex_t> &t, const Vector<complex_t> &v)

template<>
inline void xlifepp::assignVectorTo(Vector<complex_t> &t, const Vector<real_t> &v)

template<>
inline void xlifepp::assignVectorTo(Vector<real_t> &t, const Vector<real_t> &v)

asString

string_t xlifepp::asString(GeoOperation op)

give a string representation of GeoOperation

string representation of GeoOperation

atan

complex_t xlifepp::atan(const complex_t &z)

inline SuTermVector xlifepp::atan(const SuTermVector &s)

inline SymbolicFunction &xlifepp::atan(const SymbolicFunction &f)

inline TermVector xlifepp::atan(const TermVector &s)

atan2

inline SymbolicFunction &xlifepp::atan2(const real_t &r, const SymbolicFunction &f)

inline SymbolicFunction &xlifepp::atan2(const SymbolicFunction &f, const real_t &r)

inline SymbolicFunction &xlifepp::atan2(const SymbolicFunction &f1, const SymbolicFunction &f2)

atanh

complex_t xlifepp::atanh(const complex_t &z)

real_t xlifepp::atanh(const real_t &r)

inline SuTermVector xlifepp::atanh(const SuTermVector &s)

inline SymbolicFunction &xlifepp::atanh(const SymbolicFunction &f)

inline TermVector xlifepp::atanh(const TermVector &s)

badDegreeRule

void xlifepp::badDegreeRule(int degree, const string_t &name, ShapeType sh)

error message

badNodeRule

void xlifepp::badNodeRule(int n_nodes, const string_t &name, ShapeType sh)

error message

basename

string_t xlifepp::basename(const string_t &f)

return basename of a file name using last slash and last point as delimiters

basenameWithExtension

string_t xlifepp::basenameWithExtension(const string_t &f)

return basename of a file name using last slash as delimiter

besselI

inline complex_t xlifepp::besselI(const complex_t &z, real_t N)

Modified Bessel function of the first kind and order N: I_N(z) (complex case)

template<>
inline real_t xlifepp::besselI(real_t x, real_t N)

Modified Bessel function of the first kind and real order N: I_N(x)

template<class T_>
real_t xlifepp::besselI(real_t x, T_ N)

besselI0

inline complex_t xlifepp::besselI0(const complex_t &z)

Modified Bessel function of the first kind and order 0 : I_0(z) (complex case)

real_t xlifepp::besselI0(real_t x)

Modified Bessel function of the first kind and order 0 : I_0(x)

besselI0N

std::vector<real_t> xlifepp::besselI0N(real_t x, number_t n)

Modified Bessel functions of the first kind and order 0..N.

besselI1

inline complex_t xlifepp::besselI1(const complex_t &z)

Modified Bessel function of the first kind and order 1 : I_1(z) (complex case)

real_t xlifepp::besselI1(real_t x)

Modified Bessel function of the first kind and order 1 : I_1(x)

besselJ

inline complex_t xlifepp::besselJ(const complex_t &z, real_t N)

Bessel function of the first kind and order N: J_N(z) (complex case)

template<>
inline real_t xlifepp::besselJ(real_t x, real_t N)

Bessel function of the first kind and real order N: J_N(x)

template<class T_>
real_t xlifepp::besselJ(real_t x, T_ N)

besselJ0

inline complex_t xlifepp::besselJ0(const complex_t &z)

Bessel function of the first kind and order 0 : J_0(z) (complex case)

real_t xlifepp::besselJ0(real_t x)

Bessel function of the first kind and order 0 : J_0(x)

besselJ0N

std::vector<real_t> xlifepp::besselJ0N(real_t x, number_t N)

Bessel functions of the first kind and order 0..N.

besselJ1

inline complex_t xlifepp::besselJ1(const complex_t &z)

Bessel function of the first kind and order 1 : J_1(z) (complex case)

real_t xlifepp::besselJ1(real_t x)

Bessel function of the first kind and order 1 : J_1(x)

besselJY01Test

void xlifepp::besselJY01Test(std::ostream &out)

besselK

inline complex_t xlifepp::besselK(const complex_t &z, real_t N)

Modified Bessel function of the second kind and order N: K_N(z) (complex case)

template<>
inline real_t xlifepp::besselK(real_t x, real_t N)

Modified Bessel function of the second kind and real order N: K_N(x)

template<class T_>
real_t xlifepp::besselK(real_t x, T_ N)

besselK0

inline complex_t xlifepp::besselK0(const complex_t &z)

Modified Bessel function of the second kind and order 0 : K_0(z) (complex case)

real_t xlifepp::besselK0(real_t x)

Modified Bessel function of the second kind and order 0 : K_0(x)

besselK0N

std::vector<real_t> xlifepp::besselK0N(real_t x, number_t n)

Modified Bessel functions of the second kind and order 0..N.

besselK1

inline complex_t xlifepp::besselK1(const complex_t &z)

Modified Bessel function of the second kind and order 1 : K_1(z) (complex case)

real_t xlifepp::besselK1(real_t x)

Modified Bessel function of the second kind and order 1 : K_1(x)

besselY

inline complex_t xlifepp::besselY(const complex_t &z, real_t N)

Bessel function of the second kind and order N: Y_N(z) (complex case)

template<>
inline real_t xlifepp::besselY(real_t x, real_t N)

Bessel function of the second kind and real order N: Y_N(x)

template<class T_>
real_t xlifepp::besselY(real_t x, T_ N)

besselY0

inline complex_t xlifepp::besselY0(const complex_t &z)

Bessel function of the second kind and order 0 : Y_0(z) (complex case)

real_t xlifepp::besselY0(real_t x)

Bessel function of the second kind and order 0 : Y_0(x)

besselY0N

std::vector<real_t> xlifepp::besselY0N(real_t x, number_t N)

Bessel functions of the second kind and order 0..N.

besselY0withoutSingularity

real_t xlifepp::besselY0withoutSingularity(real_t x)

besselY1

inline complex_t xlifepp::besselY1(const complex_t &z)

Bessel function of the second kind and order 0 : Y_1(z) (complex case)

real_t xlifepp::besselY1(real_t x)

Bessel function of the second kind and order 0 : Y_1(x)

besselY1withoutSingularity

real_t xlifepp::besselY1withoutSingularity(real_t x)

binomialCoefficient

number_t xlifepp::binomialCoefficient(int n, int k)

compute binomial coefficient C_n^k = n! / ( k! * (n-k)! ) (0 if k<0, n<0 or k>n) C(mx+i,i) = C(mx+i-1,i-1)*(mx+i)/i, i=1,…,min(k,n-k) (exact division) with reduction by g=gcd(C,i) before the product: the intermediate value never exceeds the result (cnk*(mx+i) overflowed for n>=63 whereas the result fits in 64 bits up to n=67) error if the result does not fit in number_t

compute binomial coefficient C_n^k = = n! / ( k! * (n-k)! )

binomialCoefficients

void xlifepp::binomialCoefficients(std::vector<number_t> &row)

compute n-th row in Pascal’s triangle of binomial coefficients

compute n-th row of Pascal binomial coefficients where n = row.size()-1

• k = 0 1 2 3 4 5

• n = 1 | 1 1

• n = 2 | 1 2 1 C^n_k = C^{n-1}_{k-1} + C^{n-1}_k , 0 <= k <= n

• n = 3 | 1 3 3 1

• n = 4 | 1 4 6 4 1

• n = 5 | 1 5 10 10 5 1 - n = ………………….

binomialCoefficientsScaled

void xlifepp::binomialCoefficientsScaled(std::vector<real_t> &row)

ompute n-th row in Pascal’s triangle of binomial coefficients scaled by 1/(n-1)!

compute n-th row of Pascal binomial coefficients scaled by (n-1)! where n = row.size()-1

biry

inline complex_t xlifepp::biry(real_t x, DiffOpType d = _id)

Airy function: Bi(x) or Bi’(x)

bitReverse

inline number_t xlifepp::bitReverse(number_t x, int log2n)

blanks

void xlifepp::blanks(std::string&, int_t n)

add to or remove from end of string n blanks(keep always first char)

blockAdmissible

template<typename I>
bool xlifepp::blockAdmissible(ClusterNode<I>*, ClusterNode<I>*, HMAdmissibilityRule, real_t eta = 1.)

admissibility rule for a cluster node product

booltoWord

string_t xlifepp::booltoWord(bool)

convert bool to string true or false

boundary

inline Geometry &xlifepp::boundary(const Geometry &g)

definition of a geometry by restriction to boundary

boundary3D

void xlifepp::boundary3D(number_t iorder, Vector<Vector<number_t>> &V4sides, number_t nbFaces, std::map<string_t, Vector<number_t>> &sideIndexV4)

boundingBox

BoundingBox xlifepp::boundingBox(const Element &elt)

BoundingBox xlifepp::boundingBox(const FeDof &fed)

BoundingBox xlifepp::boundingBox(const Point &p)

template<typename T>
BoundingBox xlifepp::boundingBox(const T&)

buildConstraints

std::map<const Unknown*, Constraints*> xlifepp::buildConstraints(const EssentialConditions &ecs)

build Constraints set from EssentialConditions (list of essential conditions)

build Constraints from EssentialConditions

• create Constraints object for each essential condition

• merge constraints involving same unknown

• if there exist a constraint coupling different unknowns merge all Constraints object in one Constraints object the output is a map of Constraints pointer indexed by unknown pointer; only one Constraints pointer in case of coupling conditions

buildInterpolationData

void xlifepp::buildInterpolationData(InterpolationType interpType, number_t dim, FEType &typ, FESubType &sub, number_t &num, SobolevType &spa)

build interpolation data from InterpolationType

buildMap

const Function *xlifepp::buildMap(const GeomDomain&, const GeomDomain&)

build map from dom1 to dom2 in simple cases

buildNameAndSuffixTransformParams

void xlifepp::buildNameAndSuffixTransformParams(std::vector<Parameter> &ps, string_t &name, string_t &suffix)

buildParamSaveToFile

void xlifepp::buildParamSaveToFile(const Parameter &p, IOFormat &iof, bool &withElementSplitting, string_t &dataName, bool &aFilePerDomain)

void xlifepp::buildParamSaveToFile(const Parameter &p, IOFormat &iof, number_t &nodesDim, bool &aFilePerDomain, bool &isBinary)

save mesh to file in format _msh, _melina ,_vtk or _vtu when aFilePerDomain is true, domain informations are also exported

input/output function

void xlifepp::buildParamSaveToFile(const Parameter &p, IOFormat &iof, string_t &dataName, bool &aFilePerDomain)

void xlifepp::buildParamSaveToFile(const Parameter &p, IOFormat &iof, string_t &dataName, bool &aFilePerDomain, InterpolationType &highOrder)

input/output function

void xlifepp::buildParamSaveToFile(const Parameter &p, StorageType &st, bool &encodingFileName)

buildSolverParams

void xlifepp::buildSolverParams(const std::vector<Parameter> &ps, real_t &tol, number_t &maxIt, real_t &omega, number_t &krylovDim, number_t &verboseLevel, string_t &name, IterativeSolverType &solverType)

main routine to manage parameters of solver constructors

buildStorage

MatrixStorage *xlifepp::buildStorage(const Space &rs, const Space &cs, StorageType st, AccessType at, StorageBuildType bt)

build a storage from a pair of Space

MatrixStorage *xlifepp::buildStorage(StorageType st, AccessType at, StorageBuildType bt, number_t dimr, number_t dimc, const std::vector<std::set<number_t>> &indices, const string_t &id = "")

build a storage from type, dimension and column indices (vector of sets)

MatrixStorage *xlifepp::buildStorage(StorageType st, AccessType at, StorageBuildType bt, number_t dimr, number_t dimc, const std::vector<std::vector<number_t>> &indices, const string_t &id = "")

build a storage from type, dimension and column indices (vector of vectors)

MatrixStorage *xlifepp::buildStorage(StorageType st, AccessType at, StorageBuildType bt, number_t dimr, number_t dimc, const string_t &id = "")

build a storage from type and dimension, no allocation of pointers (void matrix)

ByRef

template<class T>
inline RefToValue<T> xlifepp::ByRef(T &t)

RefToValue creator.

byteTo

real_t xlifepp::byteTo(number_t mem, MemoryUnit mu = _megabyte)

convert from byte to xxxbyte

capitalize

string_t xlifepp::capitalize(const string_t &s)

convert “abCdeF” to “AbCdeF”

returns string_t with initial converted to uppercase

cardan

std::vector<complex_t> xlifepp::cardan(complex_t a, complex_t b, complex_t c, complex_t d)

computes roots of degree 3 polynomial (complex Cardan method)

std::vector<complex_t> xlifepp::cardan(real_t a, real_t b, real_t c, real_t d)

computes roots of degree 3 polynomial (real Cardan method)

cbrt

complex_t xlifepp::cbrt(const complex_t &z)

real_t xlifepp::cbrt(const real_t &r)

cdiv

template<typename Scalar>
complex_t xlifepp::cdiv(Scalar xr, Scalar xi, Scalar yr, Scalar yi)

cdofPositions

std::map<DofComponent, number_t> xlifepp::cdofPositions(const std::vector<DofComponent> &cdofs)

cdof (and its dual) -> position (from 1) in a list of cdofs

chebyshevPolynomials

void xlifepp::chebyshevPolynomials(real_t, std::vector<real_t>&)

Chebyshev polynomials (of the first kind) on [-1, 1] up to order n T_0(x) = 1, T_1(x) = x, T_n(x) = 2 x T_{n-1}(x) - T_{n-2}(x) , n > 1.

checkBC

void xlifepp::checkBC(BcType &bcP, BcType &bcM, complex_t &thetaP, complex_t &thetaM)

checkCond

template<class M_p>
void xlifepp::checkCond(M_p fact_p, string_t matName)

checkConsistancy

bool xlifepp::checkConsistancy(const OperatorOnUnknown&, AlgebraicOperator, const OperatorOnUnknown&)

check opu aop opv consistancy

checkTermVectorInOperator

void xlifepp::checkTermVectorInOperator(const TermVector &tv, const string_t &op)

childNodes

void xlifepp::childNodes(Node<GeomElement> *curnode, const MeshDomain *momega, GeomElement *gelt, std::set<GeomElement*> &pickedElts)

test intersection of E1 with E2 with a tolerance (default is theEpsilon)

internal tool

clear

void xlifepp::clear(Term &t1)

user aliases to term(s) cleaning

void xlifepp::clear(Term &t1, Term &t2)

void xlifepp::clear(Term &t1, Term &t2, Term &t3)

void xlifepp::clear(Term &t1, Term &t2, Term &t3, Term &t4)

void xlifepp::clear(Term &t1, Term &t2, Term &t3, Term &t4, Term &t5)

clearProjectors

void xlifepp::clearProjectors(const Space &sp)

clear Projectors depending on a space (implemented in Projector.cpp)

clearStorages

void xlifepp::clearStorages(const Space &sp)

clear Storages depending on a space (implemented in Term.cpp)

clearTerms

void xlifepp::clearTerms(const Space &sp)

clear Terms depending on a space (implemented in Term.cpp)

clearUnknowns

void xlifepp::clearUnknowns(const Space &sp)

clear Unknowns depending on a space (implemented in Unknown.cpp)

cloneClusterTreeFeDof

void *xlifepp::cloneClusterTreeFeDof(const void *p)

cloneFunction

void *xlifepp::cloneFunction(const void *p)

cloneGeomDomain

void *xlifepp::cloneGeomDomain(const void *p)

cloneIntegrationMethod

void *xlifepp::cloneIntegrationMethod(const void *p)

cloneIntegrationMethods

void *xlifepp::cloneIntegrationMethods(const void *p)

cloneParametrization

void *xlifepp::cloneParametrization(const void *p)

cloneSpline

void *xlifepp::cloneSpline(const void *p)

cloneTermVectors

void *xlifepp::cloneTermVectors(const void *p)

cloneTransformation

void *xlifepp::cloneTransformation(const void *p)

closedCrack

inline void xlifepp::closedCrack(Geometry &g1)

user shortcut to crack one geometry

inline void xlifepp::closedCrack(Geometry &g1, Geometry &g2)

user shortcut to crack 2 geometries

inline void xlifepp::closedCrack(Geometry &g1, Geometry &g2, Geometry &g3)

user shortcut to crack 3 geometries

inline void xlifepp::closedCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4)

user shortcut to crack 4 geometries

inline void xlifepp::closedCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5)

user shortcut to crack 5 geometries

inline void xlifepp::closedCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, Geometry &g6)

user shortcut to crack 6 geometries

inline void xlifepp::closedCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, Geometry &g6, Geometry &g7)

user shortcut to crack 7 geometries

closeFile

inline void xlifepp::closeFile(FILE *data)

inline void xlifepp::closeFile(std::ifstream &data)

closestSplineParameter

static real_t xlifepp::closestSplineParameter(const Spline &sp, const Point &P)

parameter t in [0,1] of the point of a 1D spline closest to P (not restricted to C2Spline): best sample (10 per knot interval) then Newton iterations on f(t)=|Q(t)-P|^2/2

cmplx

inline const complex_t &xlifepp::cmplx(const complex_t &x)

Matrix<complex_t> xlifepp::cmplx(const Matrix<real_t> &rB)

cast a real matrix to a complex matrix

template<typename K>
MatrixEigenDense<complex_t> xlifepp::cmplx(const MatrixEigenDense<K> &mat)

complex_t xlifepp::cmplx(const Parameter&)

cast to complex_t

inline complex_t xlifepp::cmplx(const real_t &x)

various useful definition to insure consistancy with other classes

Vector<complex_t> xlifepp::cmplx(const Vector<complex_t> &a)

cast a complex vector to a complex vector

Vector<complex_t> xlifepp::cmplx(const Vector<real_t> &a)

cast a real vector to a complex vector

Vector<Vector<complex_t>> xlifepp::cmplx(const Vector<Vector<real_t>> &a)

cast a real vector to a complex vector

cast a real vector vector to a complex vector vector

coefAsString

string_t xlifepp::coefAsString(bool isFirst, const complex_t &a)

string form of a complex coefficient in a linear combination

colAmd

bool xlifepp::colAmd(number_t nbr, number_t nbc, const std::vector<number_t> &rowIndices, const std::vector<number_t> &colPointer, std::vector<number_t> &colPerm)

combine

template<typename T>
LowRankMatrix<T> xlifepp::combine(const LowRankMatrix<T> &L1, const T &s1, const LowRankMatrix<T> &L2, const T &s2, real_t eps = 0)

template<typename K>
PolynomialT<K> xlifepp::combine(const PolynomialBasisT<K> &ps, const std::vector<K> &a)

return combination a1*p1+a2*p2+…

template<typename K>
std::vector<PolynomialT<K>> xlifepp::combine(const PolynomialsBasisT<K> &ps, const std::vector<K> &a)

return combination a1*p1+a2*p2+…

template<typename T, typename K>
void xlifepp::combine(std::vector<std::pair<number_t, K>> &u, const std::map<number_t, T> &v, K a)

commonPerpendicularOfStraightLines

std::pair<Point, Point> xlifepp::commonPerpendicularOfStraightLines(const Point &Am, const Point &Ap, const Point &Bm, const Point &Bp)

common perpendicular of the straight lines defined respectively by the pair of points Am, Ap and Bm, Bp returns a pair of points defining the perpendicular the first point is on (AmAp), the second on (BmBp)

common perpendicular of the straight lines

compare

int_t xlifepp::compare(const Point &p, const real_t &s, int c)

comparaison function used by KdTree

compareGELTs

bool xlifepp::compareGELTs(const GELT &a, const GELT &b)

Comparison function of two Gmsh elements according to type and domain numbers: a < b if its type number is smaller, then if its domain number is smaller.

compareMELTs

bool xlifepp::compareMELTs(const MELT &a, const MELT &b)

compareMELTs2

bool xlifepp::compareMELTs2(const MELT2 &a, const MELT2 &b)

compareSpaceUsingSize

bool xlifepp::compareSpaceUsingSize(const Space *sp1, const Space *sp2)

compare spaces using their sizes

compColSize

inline bool xlifepp::compColSize(SuTermMatrix *sut1, SuTermMatrix *sut2)

compare SuTermMatrix regarding col sizes

completeRealReduction

void xlifepp::completeRealReduction(const TermMatrix&, TermVector&)

rebuild eliminated components of a solution (real reduction, internal tool)

complex

TermVector xlifepp::complex(const TermVector &tv)

converts a real TermVector into a complex one

complex_const_fun

complex_t xlifepp::complex_const_fun(const Point &P, Parameters &pa)

complex_matrix_const_fun

Matrix<complex_t> xlifepp::complex_matrix_const_fun(const Point &P, Parameters &pa)

complex_vector_const_fun

Vector<complex_t> xlifepp::complex_vector_const_fun(const Point &P, Parameters &pa)

complexRorC

inline complex_t xlifepp::complexRorC(const complex_t &c, const Vector<complex_t> &vc)

complexToRorC

inline complex_t xlifepp::complexToRorC(const complex_t &c, const complex_t &cc)

inline complex_t xlifepp::complexToRorC(const complex_t &c, const Matrix<complex_t> &mc)

inline real_t xlifepp::complexToRorC(const complex_t &c, const Matrix<real_t> &mr)

inline real_t xlifepp::complexToRorC(const complex_t &c, const real_t &r)

inline real_t xlifepp::complexToRorC(const complex_t &c, const Vector<real_t> &vr)

complexToT

template<class T>
inline T xlifepp::complexToT(const complex_t &c)

forced cast complex to any

template<class T>
inline T xlifepp::complexToT(const Matrix<complex_t> &c)

special forced cast complex

template<class T>
inline T xlifepp::complexToT(const Vector<complex_t> &c)

forced cast complex to any

compNext

void xlifepp::compNext(int n, int k, int a[], bool *more, int *h, int *t)

computes the compositions of the integer N into K parts

compNnzSutermMatrix

inline bool xlifepp::compNnzSutermMatrix(SuTermMatrix *sut1, SuTermMatrix *sut2)

compare SuTermMatrix regarding their numbers of non zero

composeCanonicalAndCanonical

Transformation xlifepp::composeCanonicalAndCanonical(const Transformation &t1, const Transformation &t2)

composition of canonical transformations

composeCanonicalAndComposite

Transformation xlifepp::composeCanonicalAndComposite(const Transformation &t1, const Transformation &t2)

composition of a canonical transformation and a composite transformation

composeCompositeAndCanonical

Transformation xlifepp::composeCompositeAndCanonical(const Transformation &t1, const Transformation &t2)

composition of a composite transformation and a canonical transformation

composeCompositeAndComposite

Transformation xlifepp::composeCompositeAndComposite(const Transformation &t1, const Transformation &t2)

composition of composite transformations

compRowSize

inline bool xlifepp::compRowSize(SuTermMatrix *sut1, SuTermMatrix *sut2)

compare SuTermMatrix regarding row sizes

compute

void xlifepp::compute(Term &t)

user aliases to term(s) computation

void xlifepp::compute(Term &t1, Term &t2)

void xlifepp::compute(Term &t1, Term &t2, Term &t3)

void xlifepp::compute(Term &t1, Term &t2, Term &t3, Term &t4)

void xlifepp::compute(Term &t1, Term &t2, Term &t3, Term &t4, Term &t5)

computeBilAsLin

template<typename T, typename K>
void xlifepp::computeBilAsLin(const std::pair<BasicLinearForm*, complex_t> &lf, Vector<T> &val, K &vt)

Computation of a linear form defined from a bilinear form and a TermVector to apply to l(v) = a(U,v) or l(u)=a(u,V) where U,V are some term vectors.

example: intg_gamma grad(U)|grad(v) dy U a termvector int_sigma intg_gamma (U*G)*v U a termvector

The algorithm is the most lazy one:

• go to the TermMatrix machinery to compute matrix A from a(u,v)

• do the product A*U or V*A

• add the product result to vector val

Parameters:

• lf – a pair of BasicLinearForm and coefficient

• val – vector of values to fill in

• vt – type of value type

computeGeometricalQuantities

void xlifepp::computeGeometricalQuantities(const Point &S1, const Point &S2, const Point &S3, const Point &normalT, const Point &X, Vector<Point> &I, real_t &h, bool I3)

Internal functions

computeHMatrix

template<typename T, typename K, typename I>
void xlifepp::computeHMatrix(const SuBilinearForm &subf, HMatrix<T, I> &mat, K &vt, Space *space_u_p, Space *space_v_p, const Unknown *u_p, const TestFct *v_p)

IE computation of a scalar SuBiinearForm on a == unique domain == using HMatrix method type T: type of the matrix coefficient K: type of computation (real or complex) I: type of the tree node index of the HMatrix.

subf: a single unknown bilinear form defined on a unique domains pair (assumed) mat: the HMatrix, its structure is assumed to be up to date space_u_p, space_v_p: pointers to real u-space and real v-space vt: to pass as template the scalar type (real or complex)

computeMatel

template<typename T, typename K>
void xlifepp::computeMatel(LargeMatrix<T> &mat, std::vector<number_t> &adrs, bool sym, const Quadrature *quad, bool upmapdata, GeomMapData *mapdata, Vector<real_t> &nv, K coef, bool invJacobian, bool normalRequired, AlgebraicOperator aop, bool uonE1, bool vonE1, RefElement *relt_u, GeomElement *gelt_u, number_t side_u, MeshElement *melt_u, bool upmapdata_u, GeomMapData *mapdata_u, number_t nbc_u, number_t nbt_u, const OperatorOnUnknown &op_u, number_t ord_opu, bool mapsh_u, FEMapType femt_u, bool rotsh_u, bool changeSign_u, Vector<real_t> *sign_u, dimen_t dimfun_u, std::vector<ShapeValues> &shv_us, std::vector<number_t> &dofNum_u, RefElement *relt_v, GeomElement *gelt_v, number_t side_v, MeshElement *melt_v, bool upmapdata_v, GeomMapData *mapdata_v, number_t nbc_v, number_t nbt_v, const OperatorOnUnknown &op_v, number_t ord_opv, bool mapsh_v, FEMapType femt_v, bool rotsh_v, bool changeSign_v, Vector<real_t> *sign_v, dimen_t dimfun_v, std::vector<ShapeValues> &shv_vs, std::vector<number_t> &dofNum_v, const std::vector<number_t> &perm = std::vector<number_t>())

computeNormalsAt

std::vector<Vector<real_t>> xlifepp::computeNormalsAt(const GeomDomain &dom, const std::vector<Point> &xs, ProjectorType pt = _noProjectorType, OrientationType orient = _undefOrientationType, const GeomDomain *gp = nullptr)

compute normals at some points of a GeomDomain

computePartialIE

template<typename T, typename K>
void xlifepp::computePartialIE(const SuBilinearForm &subf, LargeMatrix<T> &mat, K &vt, const std::vector<number_t> &rowDofs, const std::vector<number_t> &colDofs, const std::vector<Element*> &rowElts, const std::vector<Element*> &colElts, IEcomputationParameters &ieparams, const std::list<std::multimap<real_t, IntgMeth>> &intgMaps, const std::vector<KernelOperatorOnUnknowns*> &kopregs, const std::vector<KernelOperatorOnUnknowns*> &kopsings, const std::map<Element*, GeoNumPair> &sidelts_u, const std::map<Element*, GeoNumPair> &sidelts_v, bool noUpdatedNormal, bool same_interpolation, bool sym)

partial IE computation of a scalar SuBilinearForm on a list of elements subf: a single unknown bilinear form defined on a unique domains pair (assumed) mat: matrix to build, with size rowDofs.size x colDofs.size rowDofs, colDofs: vector of row/col dofs involved rowElts, colElts: vector of row/col elements involved vt: to pass as template the scalar type (real or complex) ieparams: some precomputed IE information intgMaps: list of integration methods to be used (built outside) kopregs , kopsings: list of regular and singular kernels when required

NOTE: precomputation of normals, quadrature points, shape values, … has to be done before

computeQuadratureIE

template<typename K>
void xlifepp::computeQuadratureIE(const Element *elt_S, const Element *elt_T, const KernelOperatorOnUnknowns &kuv, Quadrature *quadx, Quadrature *quady, Matrix<K> &res, IEcomputationParameters &ieparams, Vector<K> &val_opu, Vector<K> &val_opv, Vector<K> &val_opk)

computation of elementary matrix of IE term using double quadrature (quadx, quady) intg elt_S intg elt_V opu(y) opk(x,y) opv(x) dy dx assuming precomputation of geometrical stuff (jacobian,diffelt, normals, …), shape values and mapping of quadrature points onto physical space

the template parameter K is always a scalar type (real_t or complex_t)

elt_S: element supporting u(y) elt_T: element supporting v(x) kuv: operator on kernel and unknowns opu(y) opk(x,y) opv(x) quadx: quadrature in x variable (i.e on elt_T) quady: quadrature in y variable (i.e on elt_S) ieparams: computation parameters val_opu, val_opv, val_opk: working vectors to store value of opu, opv and opk res: matrix result in SCALAR representation even the problem is a vector problem ! the calling function has to do the conversion from SCALAR MATRIX to MATRIX of MATRIX in case of vector problem

Assume here that either Kernel is Matrix or ShapeFunctions are vectors

computeRowColIE

template<typename T, typename K>
void xlifepp::computeRowColIE(const SuBilinearForm &subf, bool row, number_t rc, T *rowcol, number_t n, const std::vector<number_t> &crDofs, const std::vector<Element*> &crElts, const Space *rcSpace, IEcomputationParameters &ieparams, K &vt, const std::list<std::multimap<real_t, IntgMeth>> &intgMaps, const std::vector<KernelOperatorOnUnknowns*> &kopregs, const std::vector<KernelOperatorOnUnknowns*> &kopsings, const std::map<Element*, GeoNumPair> &sidelts_u, const std::map<Element*, GeoNumPair> &sidelts_v, bool noUpdatedNormal, bool same_interpolation, bool sym)

compute a row or a col of integral equation subf: bilinear form defining ie to compute row: true if a row computation, false if a col computation n: length of row/col rowcol: pointer to the first element of row or col, has to be correctly sized before rc: row/col index (>=1) crDofs: col/ row dof indices crElts: list of elements supporting col/row dofs rcSpace: space of row/col dof IEcomputationParameters: computation ie parameters intgMaps: list of integration methods to be used (built outside) kopregs , kopsings: list of regular and singular kernels when required

NOTE:for the moment this routine uses the general computePartialIE that involves LargeMatrix

computeSPfunByQuadrature

template<typename K>
void xlifepp::computeSPfunByQuadrature(const std::vector<Vector<K>> &val, const SpectralBasis &spbasis, const std::vector<Point> &phyPts, const Quadrature &quad, std::vector<Vector<K>> &phi_w, bool isconj, const Function *mapto = nullptr)

utility for computeSP: compute sum_q[pq*phi_m(Xq)*wj(xq)] from wj(xq) GENERAL CASE (xq, Xq) : quadrature points in reference/physical space (phi_m) : basis functions from spectral basis (pq) : quadrature weights (wj(xq)) : FE shape functions at quadrature points (already computed)

val: wj(xq)) may be d-vector shape functions: val(q) = w11(xq),w12(xq), …, w1d(xq), w21(xq), … spbasis: spectral basis (function) phyPts: physical points quad: quadrature object mapto: if non zero, pointer to the map: domain -> reference domain of spectral basis

phi_w: computed values sum_q[pq*phi_m(Xq)*wj(xq)] when isconj=false sum_q[pq*conj(phi_m(Xq))*wj(xq)] when isconj=true

computeSPintByQuadrature

template<typename K>
void xlifepp::computeSPintByQuadrature(const std::vector<Vector<K>> &val, const SpectralBasis &spbasis, const std::vector<Point> &phyPts, const Quadrature &quad, const Element &elt, const Space *space_u, const GeomDomain *dom, const std::vector<ShapeValues> &shv, std::vector<Vector<K>> &phi_w, bool isconj, const Function *mapto = nullptr)

utility for computeSP, compute sum_q[pq*phi_m(Xq) op wj(xq)] from wj(xq) (INTERPOLATED CASE, interpolated spectral basis function) (xq, Xq) : quadrature points in reference/physical space (phi_m) : basis functions from spectral basis (pq) : quadrature weights (wj(xq)) : FE shape functions at quadrature points (already computed) op: * or |, automatically detected regarding structure of SpectralBasis

phi_m(Xq) is computed by interpolation: sum_s phi_ms tau_s(xq) where phi_ms are components of phi_m in current element two cases occur:

• same interpolation (common case) -> tau_s = wj

• different interpolation -> computation of tau_s

val: wj(xq)) may be d-vector shape functions: val(q) = w11(xq),w12(xq), …, w1d(xq), w21(xq), … spbasis: spectral basis (vector) phyPts: physical points quad: quadrature object mapto: if non zero, pointer to the map: domain -> reference domain of spectral basis elt: current element space_u: space dom: current domain shv: shapevalues

phi_w: computed values Vjm=sum_q[pq*phi_m(Xq) op wj(xq)] ( say phi_w(j)=[Vj1,Vj2, …, Vjn])

computeSPOperator

template<typename K>
void xlifepp::computeSPOperator(const OperatorOnUnknown &op, const SpectralBasis *spbasis, const Point &x, ValueType vtphi, number_t nbfun, dimen_t dimfun, Vector<K> &val, const Vector<real_t> *np = nullptr)

compute values of operator on spectral unknown at quadrature point, say op(phi_n)(x) with (phi) i=1,n the spectral functions and x a quadrature point in physical space

op: operator on unknown basis: spectral basis associated to unknown x: point where operator is evaluated (in physical space of spectral functions) vtphi: value type of basis function nbfun: number of function dimfun: dimension of function val: computed values as a vector of vectors: val = (op(phi_n)(x)) i=1,n phyPoints: quadrature points in physical space

NOTE: operator with derivatives are only supported with ANALYTICAL spectral functions in Function defining them, user has to provide derivatives using the parameter “derivative” and its value Number(_dx), Number(_dxx), ….

operator with derivatives are not yet handled for VECTOR spectral functions

conj

Matrix<complex_t> xlifepp::conj(const Matrix<complex_t> &cB)

conjugate a complex matrix

conjugate complex matrix

Matrix<real_t> xlifepp::conj(const Matrix<real_t> &cB)

conjugate a real matrix (do nothing)

conjugate real matrix (compatibility)

template<typename K>
MatrixEigenDense<K> xlifepp::conj(const MatrixEigenDense<K> &mat)

MatrixEntry xlifepp::conj(const MatrixEntry &me)

return the conjugate of a matrix entry

inline const Point &xlifepp::conj(const Point &p)

inline real_t xlifepp::conj(const real_t&)

template<typename T>
inline std::vector<T> xlifepp::conj(const std::vector<T> &v)

inline SymbolicFunction &xlifepp::conj(const SymbolicFunction &f)

template<typename T>
Value &xlifepp::conj(const T &v)

TermMatrix xlifepp::conj(const TermMatrix &tm)

TermVector xlifepp::conj(const TermVector &tv)

conjugate TermVector

template<typename K>
Vector<K> xlifepp::conj(const Vector<K> &a)

conjugate a Vector<K>

template<typename K>
VectorEigenDense<K> xlifepp::conj(const VectorEigenDense<K> &v)

Conjugate a vector.

Parameters:

v – [in] source vector

Returns:

conjugated vector

OperatorOnFunction &xlifepp::conj(Function&)

conjugate f

OperatorOnKernel &xlifepp::conj(Kernel&)

conjugate k

OperatorOnFunction &xlifepp::conj(OperatorOnFunction&)

conjugate opf

OperatorOnKernel &xlifepp::conj(OperatorOnKernel&)

conjugate opk

SymbolicTermMatrix &xlifepp::conj(SymbolicTermMatrix &S)

template<typename T>
inline Function &xlifepp::conj(T (*fun)(const Point&, const Point&, Parameters&))

template<typename T>
inline Function &xlifepp::conj(T (*fun)(const Point&, Parameters&))

template<typename T>
inline Function &xlifepp::conj(T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&))

template<typename T>
inline Function &xlifepp::conj(T (*fun)(const Vector<Point>&, Parameters&))

inline Unknown &xlifepp::conj(TestFunction &v)

Unknown &xlifepp::conj(Unknown&)

set to true or false the temporary conjugate flag

Value &xlifepp::conj(Value &v)

set to true or false the temporary conjugate flag

conjTpl

template<typename T1_iterator, typename R_iterator>
void xlifepp::conjTpl(T1_iterator b1, T1_iterator e1, R_iterator Rb)

returns complex conjugate of vector entries: R[i] = conj(T1[i])

constructorError

void xlifepp::constructorError()

message sent when in trouble in object constructor

continuedFractionOfE1

complex_t xlifepp::continuedFractionOfE1(const complex_t &z)

continued fraction in E1 formula (used for ‘large’ z)

convertmeshfile

int xlifepp::convertmeshfile(const string_t &inputfilename, string_t &outputfilename)

convexHull2D

std::vector<Point> xlifepp::convexHull2D(std::vector<Point> P)

convex hull of 2D points

convex hull in 2D

coords

real_t xlifepp::coords(const Element &elt, dimen_t i)

real_t xlifepp::coords(const FeDof &fed, dimen_t i)

real_t xlifepp::coords(const Point &p, dimen_t i)

template<typename T>
real_t xlifepp::coords(const T &p, dimen_t i)

cos

inline SuTermVector xlifepp::cos(const SuTermVector &s)

inline SymbolicFunction &xlifepp::cos(const SymbolicFunction &f)

inline TermVector xlifepp::cos(const TermVector &s)

cosh

inline SuTermVector xlifepp::cosh(const SuTermVector &s)

inline SymbolicFunction &xlifepp::cosh(const SymbolicFunction &f)

inline TermVector xlifepp::cosh(const TermVector &s)

cpp11

inline bool xlifepp::cpp11()

cpuTime

real_t xlifepp::cpuTime()

returns user time (“cputime”) interval since last runtime ‘call’ according to unit defined in Time::deltaCpuTime

returns user time (“cputime”) interval in sec.

since last runtime ‘call’

real_t xlifepp::cpuTime(const string_t &comment, CoutStream &out)

real_t xlifepp::cpuTime(const string_t &comment, PrintStream &out)

real_t xlifepp::cpuTime(const string_t &comment, std::ostream &out = std::cout)

returns user time (“cputime”) interval in sec.

since last runtime ‘call’ and prints it with comment

crack

GeomDomain &xlifepp::crack(const GeomDomain &side1, const GeomDomain &side2)

defined a crack domain from both sides of the crack in fact, define the crack domain as side 1

defined a crack domain from both sides of the crack (alias)

void xlifepp::crack(Geometry &g1, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack one geometry

void xlifepp::crack(Geometry &g1, Geometry &g2, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack 2 geometries

void xlifepp::crack(Geometry &g1, Geometry &g2, Geometry &g3, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack 3 geometries

void xlifepp::crack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack 4 geometries

void xlifepp::crack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack 5 geometries

void xlifepp::crack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, Geometry &g6, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack 6 geometries

void xlifepp::crack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, Geometry &g6, Geometry &g7, CrackType ct = _closedCrack, string_t domNameToOpen = string_t())

user shortcut to crack 7 geometries

createCdofs

std::vector<DofComponent> xlifepp::createCdofs(const Unknown *u, const std::vector<number_t> &dofs)

create cdofs from unknown dofs

createMatrixStorage

MatrixStorage *xlifepp::createMatrixStorage(StorageType st, AccessType at, StorageBuildType sb, number_t nbr, number_t nbc, const std::vector<std::vector<number_t>> &indices, const string_t &idu)

create matrix storage from indices (vector of column indices for each row)

createPath

void xlifepp::createPath(Node<GeomElement>*, std::map<GeomElement*, bool>&, std::map<string_t, std::list<GeomElement*>>&)

utility

createSideEltIndex

void xlifepp::createSideEltIndex(const std::vector<GeomElement*> &elements, std::map<string_t, GeomElement*> &sideEltIndex)

create an index of all side elements in given side element list, do not clear current sideEltIndex !

create the side index map of side elements of a list of elements

createSideIndex

void xlifepp::createSideIndex(const MeshDomain &mdom, std::map<string_t, std::vector<GeoNumPair>> &sideIndex)

create an index of all sides of a meshDomain similar to previous one, but dedicated to any domain

create the side index map of a MeshDomain

void xlifepp::createSideIndex(const std::vector<GeomElement*> &elements, std::map<string_t, std::vector<GeoNumPair>> &sideIndex)

create an index of all sides of a list of elements very similar to buildSides function except the fact that no new side element are created do not clear current sideIndex !

create the side index map of a list of elements

createTeXFile

void xlifepp::createTeXFile(const string_t &TeXFilename, subdivision::SubdivisionMesh *TM_p, const float psi, const float theta, const number_t nbviews, const std::string &DimProj, const bool withInterface, const bool withElems)

create TeX file, using Fig4TeX macros, to draw the mesh

cross3D

inline Point xlifepp::cross3D(const Point &A, const Point &B)

crossProduct

inline complex_t xlifepp::crossProduct(const complex_t &x, const complex_t &y)

inline complex_t xlifepp::crossProduct(const complex_t &x, const real_t &y)

Point xlifepp::crossProduct(const Point&, const Point&)

returns the cross product of 2 points

inline complex_t xlifepp::crossProduct(const real_t &x, const complex_t &y)

inline real_t xlifepp::crossProduct(const real_t &x, const real_t &y)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::crossProduct(const std::vector<PolynomialT<K>> &p, const std::vector<K> &v)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::crossProduct(const std::vector<PolynomialT<K>> &p, const std::vector<PolynomialT<K>> &q)

template<typename T>
std::vector<T> xlifepp::crossProduct(const std::vector<T> &u, const std::vector<T> &v)

crossproduct of two vectors (dimension 2 and 3), be care in 2D return a 1-vector

template<typename T, typename K>
T xlifepp::crossProduct(const T &v, const K &s)

Vector<complex_t> xlifepp::crossProduct(const Vector<complex_t> &u, const Vector<real_t> &v)

Specialization complex_t/real_t of cross product.

template<typename K, typename IteratorV, typename IteratorR>
void xlifepp::crossProduct(const Vector<K> &u, const IteratorV &itv, IteratorR &itr)

cross product with vector and iterator in 3D and 2D (return a scalar)

template<typename K>
Vector<K> xlifepp::crossProduct(const Vector<K> &u, const Vector<K> &v)

cross product in 3D

Vector<complex_t> xlifepp::crossProduct(const Vector<real_t> &u, const Vector<complex_t> &v)

crossProduct2D

real_t xlifepp::crossProduct2D(const Point &A, const Point &B)

real_t xlifepp::crossProduct2D(const Point &O, const Point &A, const Point &B)

returns the cross product OAxOB (2D)

template<typename T, typename K>
T xlifepp::crossProduct2D(const T &v, const K &s)

complex_t xlifepp::crossProduct2D(const Vector<complex_t> &u, const Vector<real_t> &v)

template<typename K>
K xlifepp::crossProduct2D(const Vector<K> &u, const Vector<K> &v)

cross product in 2D, return a scalar

complex_t xlifepp::crossProduct2D(const Vector<real_t> &u, const Vector<complex_t> &v)

curl

template<typename K>
std::vector<PolynomialT<K>> xlifepp::curl(const MonomialT<K> &m, dimen_t d = 3)

template<typename K>
PolynomialsBasisT<K> xlifepp::curl(const PolynomialsBasisT<K> &ps)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::curl(const PolynomialT<K> &p, dimen_t d = 3)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::curl(const std::vector<PolynomialT<K>> &p)

OperatorOnUnknown &xlifepp::curl(const Unknown &un)

curl_x

OperatorOnKernel &xlifepp::curl_x(const Kernel&)

curl_x(k)

OperatorOnKernel &xlifepp::curl_x(OperatorOnKernel&)

curl_x(opk)

curl_y

OperatorOnKernel &xlifepp::curl_y(const Kernel&)

curl_y(k)

OperatorOnKernel &xlifepp::curl_y(OperatorOnKernel&)

curl_y(opk)

curlG

OperatorOnUnknown &xlifepp::curlG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)

curlS

OperatorOnUnknown &xlifepp::curlS(const Unknown &un)

currentThread

inline number_t xlifepp::currentThread()

if omp is available, return the current thread number else return 0

curThread

inline number_t xlifepp::curThread()

if omp is available, return the current thread number else return 0

cylinderSidePartGeodesic

Vector<real_t> xlifepp::cylinderSidePartGeodesic(const Point &P, Parameters &params, DiffOpType dif)

cylinderSidePartGeodesicCurvatures

Vector<real_t> xlifepp::cylinderSidePartGeodesicCurvatures(const Point &p, const Point &d, bool fromParameters, Parameters &pars)

cylinderSidePartGeodesicNormal

Vector<real_t> xlifepp::cylinderSidePartGeodesicNormal(const Point &p, bool fromParameters, Parameters &pars)

d0

OperatorOnUnknown &xlifepp::d0(const Unknown &un)

d1

OperatorOnUnknown &xlifepp::d1(const Unknown &un)

d11

OperatorOnUnknown &xlifepp::d11(const Unknown &un)

d12

OperatorOnUnknown &xlifepp::d12(const Unknown &un)

d13

OperatorOnUnknown &xlifepp::d13(const Unknown &un)

d2

OperatorOnUnknown &xlifepp::d2(const Unknown &un)

d22

OperatorOnUnknown &xlifepp::d22(const Unknown &un)

d23

OperatorOnUnknown &xlifepp::d23(const Unknown &un)

d2G

OperatorOnUnknown &xlifepp::d2G(const Unknown &un, const complex_t &axx, const complex_t &axy, const complex_t &ayy, const complex_t &axz, const complex_t &ayz, const complex_t &azz)

OperatorOnUnknown &xlifepp::d2G(const Unknown &un, const Matrix<complex_t> &a)

d3

OperatorOnUnknown &xlifepp::d3(const Unknown &un)

d33

OperatorOnUnknown &xlifepp::d33(const Unknown &un)

deceol

inline void xlifepp::deceol(number_t n)

decrease blanks

defaultColoringRule

real_t xlifepp::defaultColoringRule(const GeomElement &gelt, const std::vector<real_t> &val)

the default GeomElement coloring rule is the following let np the number of strictly positive values (v_i) on the n vertices of the geomelement if(np>n/2) then color =1 else color =0 for a triangle: color is 1 if at least 2 vertex values are >0 for a quadrangle: color is 1 if at least 3 vertex values are >0 for a tetrahedron: color is 1 if at least 3 vertex values are >0 for a hexahedron: color is 1 if at least 5 vertex values are >0

default Geomelement coloring rule

gelt: geom element val: real values on vertices

defaultVectorColoringRule

real_t xlifepp::defaultVectorColoringRule(const GeomElement &gelt, const std::vector<Vector<real_t>> &val)

default Geomelement vector coloring rule

defineMap

void xlifepp::defineMap(const GeomDomain&, const GeomDomain&, const Function&, bool nearest = false)

define a map between 2 geomdomains, default name

void xlifepp::defineMap(const GeomDomain&, const GeomDomain&, const Function&, const string_t&, bool nearest = false)

define a map between 2 geomdomains with explicit name

deleteClusterTreeFeDof

void xlifepp::deleteClusterTreeFeDof(void *p)

deleteFunction

void xlifepp::deleteFunction(void *p)

deleteGeomDomain

void xlifepp::deleteGeomDomain(void *p)

deleteIntegrationMethod

void xlifepp::deleteIntegrationMethod(void *p)

deleteIntegrationMethods

void xlifepp::deleteIntegrationMethods(void *p)

deleteMapOfPair

static void xlifepp::deleteMapOfPair(const GeomDomain &d1, const GeomDomain &d2)

deleteParametrization

void xlifepp::deleteParametrization(void *p)

deleteSpline

void xlifepp::deleteSpline(void *p)

deleteTermVectors

void xlifepp::deleteTermVectors(void *p)

deleteTransformation

void xlifepp::deleteTransformation(void *p)

delSpace

string_t xlifepp::delSpace(const string_t &s)

convert “ a b c d e f “ to “abcefd”

delete all white space from string_t

derivative

SymbolicFunction &xlifepp::derivative(const SymbolicFunction &f, const SymbolicFunction &v)

SymbolicFunction &xlifepp::derivative(const SymbolicFunction &f, VariableName v)

template<typename K>
PolynomialT<K> xlifepp::derivative(VariableName vn, const MonomialT<K> &m)

template<typename K>
PolynomialT<K> xlifepp::derivative(VariableName vn, const PolynomialT<K> &p)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::derivative(VariableName vn, const std::vector<PolynomialT<K>> &ps)

diag

inline complex_t xlifepp::diag(const complex_t&)

inline real_t xlifepp::diag(const real_t&)

template<typename K>
void xlifepp::diag(Matrix<K> &m)

change matrix into diagonal matrix made of diagonal of matrix

diagonalLumping

SuTermMatrix xlifepp::diagonalLumping(const SuTermMatrix&, AccessType = _row)

diagonal matrix sum_j aij (_row) or sum_i aij (col)

inline TermMatrix xlifepp::diagonalLumping(const TermMatrix &A, AccessType at = _row)

create diagonal TermMatrix dii= sum_j Aij (at=_row) or djj= sum_i Aij (at=col), works only for single unknown TermMatrix

diagonalMatrix

template<typename T>
LargeMatrix<T> xlifepp::diagonalMatrix(const LargeMatrix<T> &mat, const T v)

template<typename T>
LargeMatrix<T> xlifepp::diagonalMatrix(StorageType st, AccessType at, number_t nbr, number_t nbc, const T v)

diagonalPart

SuTermMatrix xlifepp::diagonalPart(const SuTermMatrix&)

diagonal matrix from aii

inline TermMatrix xlifepp::diagonalPart(const TermMatrix &A)

create diagonal TermMatrix dii from Aii, works only for single unknown TermMatrix

diGamma

complex_t xlifepp::diGamma(const complex_t &z)

real_t xlifepp::diGamma(int_t n)

return \(-gamma + \sum_1^{n-1} 1/n\) where gamma is Euler-Mascheroni constant

real_t xlifepp::diGamma(real_t x)

dim

dimen_t xlifepp::dim(const Element &elt)

dimen_t xlifepp::dim(const FeDof &fed)

dimen_t xlifepp::dim(const Point &p)

template<typename T>
dimen_t xlifepp::dim(const T&)

dimsOf

std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const complex_t &v)

template<typename K>
std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const Matrix<K> &v)

std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const real_t &v)

template<typename K>
std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const SparseMatrix<K> &v)

template<typename T>
std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const Vector<T> &v)

useful dimension functions

directSolve

TermVectors xlifepp::directSolve(TermMatrix &A, const std::vector<TermVector> &Bs, bool keepA)

TermVector xlifepp::directSolve(TermMatrix &A, const TermVector &B, bool keepA)

solve linear system by direct method, trying to find the well adapted direct method if A is already factorized goto upper-lower solver (factSolve) if umfpack is available, it is used (umfpackSolve) if A is single unknown dense matrix use pivoting gauss elimination process (gaussSolve) else factorize LU, LDLt or LDL* and goto upper-lower solver (factSolve)

if keepA is false (default) the matrix A is modified else it is not modified

TermMatrix xlifepp::directSolve(TermMatrix &A, TermMatrix &B, KeepStatus k)

dirname

string_t xlifepp::dirname(const string_t &f)

return dirname of a file name using last slash as delimiter

dist

real_t xlifepp::dist(const BoundingBox &bb1, const BoundingBox &bb2)

distance from two bounding boxes

real_t xlifepp::dist(const Point &p, const Point &q)

returns Point as Point in polar coordinates/cylindrical (r,theta,z) r=sqrt(x*x+y*y) theta = atan2(y,x) in ]-pi,pi], z unchanged reverse map: x= r cos(theta) y = r sin(theta) z= z

returns the euclidian distance between 2 points

distance

real_t xlifepp::distance(const MeshElement &elt1, const MeshElement &elt2)

distance from two MeshElement, assuming not intersection and using first order, i.e vertices under these assumptions dist(e1,e2)= min{dist(p1,p2), p1 in e1, p2 in e2} = min{dist(p1,p2), p1 any vertex of e1, p2 any vertex of e2}

distance from two MeshElement

div

template<typename K>
PolynomialBasisT<K> xlifepp::div(const PolynomialsBasisT<K> &ps)

template<typename K>
PolynomialT<K> xlifepp::div(const std::vector<PolynomialT<K>> &p)

OperatorOnUnknown &xlifepp::div(const Unknown &un)

div_x

OperatorOnKernel &xlifepp::div_x(const Kernel&)

grad_x(k)

OperatorOnKernel &xlifepp::div_x(OperatorOnKernel&)

grad_x(opk)

div_y

OperatorOnKernel &xlifepp::div_y(const Kernel&)

grad_y(k)

OperatorOnKernel &xlifepp::div_y(OperatorOnKernel&)

grad_y(opk)

divG

OperatorOnUnknown &xlifepp::divG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)

divS

OperatorOnUnknown &xlifepp::divS(const Unknown &un)

doesQuadrangleIntersectsQuadrangle

bool xlifepp::doesQuadrangleIntersectsQuadrangle(const Point &P, const Point &Q, const Point &R, const Point &S, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)

determines if quadrangles PQRS and ABCD have a intersection or not

doesSegmentCrossesQuadrangle

bool xlifepp::doesSegmentCrossesQuadrangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)

determines if a segment [PQ] and a quadrangle ABCD have a unique intersection or not

doesSegmentCrossesSegment

bool xlifepp::doesSegmentCrossesSegment(const Point &P, const Point &Q, const Point &A, const Point &B, real_t tol)

determines if 2 segments [PQ] and [AB] have a unique intersection or not (2D or 3D)

doesSegmentCrossesSegment2D

bool xlifepp::doesSegmentCrossesSegment2D(const Point &P, const Point &Q, const Point &A, const Point &B, real_t tol)

determines if 2 2D segments [PQ] and [AB] have a unique intersection or not

determines if 2 segments [PQ] and [AB] have a intersection or not (faster 2D version)

doesSegmentCrossesTriangle

bool xlifepp::doesSegmentCrossesTriangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, real_t tol)

determines if a segment [PQ] and a triangle ABC have a unique intersection or not

doesSegmentIntersectsQuadrangle

bool xlifepp::doesSegmentIntersectsQuadrangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)

determines if a segment [PQ] and a triangle ABC have a intersection or not

doesSegmentIntersectsTriangle

bool xlifepp::doesSegmentIntersectsTriangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, real_t tol)

determines if segments [PQ] and [AB] have a intersection or not

doesTriangleIntersectsQuadrangle

bool xlifepp::doesTriangleIntersectsQuadrangle(const Point &P, const Point &Q, const Point &R, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)

determines if a triangle PQR and a quadrangle ABCD have a intersection or not

doesTriangleIntersectsTriangle

bool xlifepp::doesTriangleIntersectsTriangle(const Point &P, const Point &Q, const Point &R, const Point &A, const Point &B, const Point &C, real_t tol)

determines if triangles PQR and ABC have a intersection or not

dofCoords

std::vector<Point> xlifepp::dofCoords(Space &sp, const GeomDomain &dom)

list of coordinates of ponctual dofs of Space on a given domain

domainFromParameters

inline const GeomDomain *xlifepp::domainFromParameters(Parameters &pars)

domainIdFromParameters

inline number_t xlifepp::domainIdFromParameters(Parameters &pars)

domainMap

const DomainMap *xlifepp::domainMap(const GeomDomain&, const GeomDomain&)

find DomainMap from dom1 to dom2

domainNameFromParameters

inline string_t xlifepp::domainNameFromParameters(Parameters &pars)

extract GeomDomain or GeomElement information from Parameters

Note

if pointer parameter does not exist, it is created with 0 value (see Parameters.get member function)

domainsFromLevelSet

inline std::vector<number_t> xlifepp::domainsFromLevelSet(TermVector &tv, number_t mainDomNum, number_t insideDomNum, bool outside = true)

std::vector<number_t> xlifepp::domainsFromLevelSet(TermVector &tv, number_t mainDomNum, std::vector<number_t> insideDomNums, bool outside)

routine to update inner domains and main domain regarding some values on element

Parameters:

• tv – : real single unknown TermVector containing the criteria : v(i)<0 -> inner domain v(i)>0 main domain

• mainDomNum – domain number of the main domain (the domain number is the index in Mesh::domains_)

• insideDomNums – domain numbers of inner domains (one or more)

• outside – if true, elements of interface between main domain and inner domains (obstacles) are considered in the inner domain, in the main domain otherwise.

Returns:

vector<number_t> eltCol : new domain number for each element

domainTranslation

Vector<real_t> xlifepp::domainTranslation(const Point&, Parameters &pa = defaultParameters)

default translation for domain map

dot

inline complex_t xlifepp::dot(const complex_t &x, const complex_t &y)

inline complex_t xlifepp::dot(const complex_t &x, const real_t &y)

real_t xlifepp::dot(const Point&, const Point&)

returns the scalar product between 2 points

inline complex_t xlifepp::dot(const real_t &x, const complex_t &y)

inline real_t xlifepp::dot(const real_t &x, const real_t &y)

for template compilation reasons, fake definition of dot and crossproduct in 1D

template<typename K>
PolynomialT<K> xlifepp::dot(const std::vector<PolynomialT<K>> &p, const std::vector<K> &v)

template<typename K>
PolynomialT<K> xlifepp::dot(const std::vector<PolynomialT<K>> &p, const std::vector<PolynomialT<K>> &q)

complex_t xlifepp::dot(const Vector<complex_t> &u, const Vector<real_t> &v)

Specialization of dot (complex_t real_t)

complex_t xlifepp::dot(const Vector<complex_t> &vecFirst, const Vector<complex_t> &vecSecond)

template<typename K>
K xlifepp::dot(const Vector<K> &u, const Vector<K> &v)

inner product for real and complex

complex_t xlifepp::dot(const Vector<real_t> &u, const Vector<complex_t> &v)

dotC

complex_t xlifepp::dotC(const Vector<complex_t> &vecFirst, const Vector<real_t> &vecSecond)

template<typename K1, typename K2>
complex_t xlifepp::dotC(const Vector<K1> &vecFirst, const Vector<K2> &vecSecond)

Hermitian Inner product.

complex_t xlifepp::dotC(const Vector<real_t> &vecFirst, const Vector<real_t> &vecSecond)

Specialization of dotC (real_t real_t) and (complex_t real_t)

dotProduct

template<typename T, typename K>
T xlifepp::dotProduct(const std::vector<std::pair<number_t, T>> &u, const std::map<number_t, K> &v)

dotRC

complex_t xlifepp::dotRC(const TermVector &tv1, const TermVector &tv2)

inner product when one TermVector is complex

template<typename K1, typename K2>
complex_t xlifepp::dotRC(const Vector<K1> &vecFirst, const Vector<K2> &vecSecond)

Inner product with COMPLEX result (not hermitian product)

complex_t xlifepp::dotRC(const Vector<real_t> &vecFirst, const Vector<real_t> &vecSecond)

Specialization of dotRC (real_t real_t)

complex_t xlifepp::dotRC(const VectorEntry&, const VectorEntry&)

same as inner product of two vectorentry’s

dt

OperatorOnUnknown &xlifepp::dt(const Unknown &un)

dualDofComponents

std::vector<DofComponent> xlifepp::dualDofComponents(const std::vector<DofComponent> &cdofs)

create dual cdofs list from cdofs list

dualOf

inline TestFunctions xlifepp::dualOf(const PCollection<Unknown> &us, const Strings &names = Strings())

to build a list of dual xlifepp::TestFunction of a list of xlifepp::Unknown

dx

template<typename K>
PolynomialT<K> xlifepp::dx(const MonomialT<K> &m)

template<typename K>
PolynomialBasisT<K> xlifepp::dx(const PolynomialBasisT<K> &ps)

template<typename K>
PolynomialsBasisT<K> xlifepp::dx(const PolynomialsBasisT<K> &ps)

template<typename K>
PolynomialT<K> xlifepp::dx(const PolynomialT<K> &p)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::dx(const std::vector<PolynomialT<K>> &ps)

OperatorOnUnknown &xlifepp::dx(const Unknown &un)

dxx

OperatorOnUnknown &xlifepp::dxx(const Unknown &un)

dxy

OperatorOnUnknown &xlifepp::dxy(const Unknown &un)

dxz

OperatorOnUnknown &xlifepp::dxz(const Unknown &un)

dy

template<typename K>
PolynomialT<K> xlifepp::dy(const MonomialT<K> &m)

template<typename K>
PolynomialBasisT<K> xlifepp::dy(const PolynomialBasisT<K> &ps)

template<typename K>
PolynomialsBasisT<K> xlifepp::dy(const PolynomialsBasisT<K> &ps)

template<typename K>
PolynomialT<K> xlifepp::dy(const PolynomialT<K> &p)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::dy(const std::vector<PolynomialT<K>> &ps)

OperatorOnUnknown &xlifepp::dy(const Unknown &un)

dyy

OperatorOnUnknown &xlifepp::dyy(const Unknown &un)

dyz

OperatorOnUnknown &xlifepp::dyz(const Unknown &un)

dz

template<typename K>
PolynomialT<K> xlifepp::dz(const MonomialT<K> &m)

template<typename K>
PolynomialBasisT<K> xlifepp::dz(const PolynomialBasisT<K> &ps)

template<typename K>
PolynomialsBasisT<K> xlifepp::dz(const PolynomialsBasisT<K> &ps)

template<typename K>
PolynomialT<K> xlifepp::dz(const PolynomialT<K> &p)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::dz(const std::vector<PolynomialT<K>> &ps)

OperatorOnUnknown &xlifepp::dz(const Unknown &un)

dzz

OperatorOnUnknown &xlifepp::dzz(const Unknown &un)

e1Test

void xlifepp::e1Test(std::ostream&)

For tests.

e1z

complex_t xlifepp::e1z(const complex_t &z)

return E1(z)

earcut

template<typename Polygon>
std::vector<size_t> xlifepp::earcut(const Polygon &poly)

earcutTriangulation

template<typename P>
std::vector<std::vector<size_t>> xlifepp::earcutTriangulation(const std::vector<P> &vertices)

edgeNumbering

template<class ST_>
number_t *xlifepp::edgeNumbering()

Termination of the construction of a mesh object of 2D elements by transferring data from a subdivision::xxxMesh object into XLiFE++ objects.

eigenDavidsonSolve

template<typename ST>
number_t xlifepp::eigenDavidsonSolve(const LargeMatrix<ST> *pA, const LargeMatrix<ST> *pB, std::vector<std::pair<complex_t, Vector<complex_t>>> &res, number_t nev, real_t tol, string_t which, bool isInverted, FactorizationType fac, bool isShift)

Resolve an eigen problem with block davidson method.

Parameters:

• pA – [in] Pointer to large matrix A of the eigen problem A*X = lambda*B*X. It MUSTN’T be nullptr

• pB – [in] Pointer to large matrix B of the eigen problem A*X = lambda*B*X. If it’s nullptr. Eigen problem is standard: A*X=lambda*X

• res – [inout] result

• nev – [in] The number of eigen values and eigenSolver searched for

• tol – [in] Tolerance

• which – [in] Specification of which eigen values are returned. Largest-LM, Smallest-SM,

• isInverted – [in] true if inverted matrix

• fac – [in] factorization type

• isShift – [in] true if eigen problem with shift or not

eigenInternGen

EigenElements xlifepp::eigenInternGen(TermMatrix *pA, TermMatrix *ptB, number_t nev, string_t which, real_t tol, EigenComputationalMode eigCompMode, complex_t sigma, bool isShift, string_t nam, EigenSortKind esortk = _incr_module)

Internal eigen solver.

eigenInternSolve

EigenElements xlifepp::eigenInternSolve(TermMatrix *A, TermMatrix *B, const std::vector<Parameter> &ps)

Main entry point for intern eigenvalue solver.

eigenKrylovSchurSolve

template<typename ST>
number_t xlifepp::eigenKrylovSchurSolve(const LargeMatrix<ST> *pA, const LargeMatrix<ST> *pB, std::vector<std::pair<complex_t, Vector<complex_t>>> &res, number_t nev, real_t tol, string_t which, bool isInverted, FactorizationType fac, bool isShift)

Resolve an eigen problem with block Krylov-Schur method.

Parameters:

• pA – [in] Pointer to large matrix A of the eigen problem A*X = lambda*B*X. It MUSTN’T be nullptr

• pB – [in] Pointer to large matrix B of the eigen problem A*X = lambda*B*X. If it’s nullptr. Eigen problem is standard: A*X=lambda*X

• res – [inout] result

• nev – [in] The number of eigen values and eigenSolver searched for

• tol – [in] Tolerance

• which – [in] Specification of which eigen values are returned. Largest-LM, Smallest-SM,

• isInverted – [in] true if inverted matrix

• fac – [in] factorization type

• isShift – [in] true if eigen problem with shift or not

eigenSolve

EigenElements xlifepp::eigenSolve(TermMatrix *A, TermMatrix *B, std::vector<Parameter> ps)

Main entry point for non specific eigenvalue solver.

eigs

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, const Matrix<T> &B, Vector<complex_t> &ls, Matrix<complex_t> &Xs)

computation of generalized eigen values A*X=lambda*B*X

eigen vectors are stored by row in Xs matrix !

currently works only for REAL matrices

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, const Matrix<T> &B, Vector<complex_t> &ls, Vector<Vector<complex_t>> &Xs)

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, Vector<complex_t> &ls, Matrix<complex_t> &Xs)

computation of eigen values A*X=lambda*X

eigen vectors are stored by row in Xs matrix !

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, Vector<complex_t> &ls, Vector<Vector<complex_t>> &Xs)

template<typename T>
void xlifepp::eigs(const T *A, number_t m, complex_t *Xs, complex_t *ls)

general template eigenvector computation using Eigen, assuming A, U are pointers to first value of DENSE ROW matrix A, B: pointers to dense row squared matrix m: matrix size Xs: pointer to a dense row matrix, storing eigen vectors ls: pointer to a vector, storing eigen values

template<typename Ta, typename Tb>
void xlifepp::eigs(const Ta *A, const Tb *B, number_t m, complex_t *Xs, complex_t *lambda)

eInz

complex_t xlifepp::eInz(const complex_t &z)

return \(E1(z) + gamma + log(z) = \sum_{n>0} (-z)^n / n n!\)

elapsedTime

real_t xlifepp::elapsedTime()

returns elapsed time interval since last runtime ‘call’ according to unit defined in Time::deltaTime

returns elapsed time interval in sec.

since last runtime ‘call’

real_t xlifepp::elapsedTime(const string_t &comment, CoutStream &out)

real_t xlifepp::elapsedTime(const string_t &comment, PrintStream &out)

real_t xlifepp::elapsedTime(const string_t &comment, std::ostream &out = std::cout)

returns elapsed time interval in sec.

since last runtime ‘call’ and prints it with comment

eliminatedPositions

static std::vector<number_t> xlifepp::eliminatedPositions(const Constraints &cs, const std::map<DofComponent, number_t> &melcdofs)

eolpm

inline void xlifepp::eolpm(int_t n)

adding n blank (may be negatif) to eol

epsilon

OperatorOnUnknown &xlifepp::epsilon(const Unknown &un)

epsilonG

OperatorOnUnknown &xlifepp::epsilonG(const Unknown &un, const complex_t &id, const complex_t &ax, const complex_t &ay, const complex_t &az)

epsilonR

OperatorOnUnknown &xlifepp::epsilonR(const Unknown &un)

eqtOfPlane

std::vector<real_t> xlifepp::eqtOfPlane(const Point &S1, const Point &S2, const Point &S3)

returns coefficients (a,b,c,d) of the equation of the plane (ax+by+cz+d=0) defined by the 3 non aligned given points S1, S2, and S3

returns equation of the plane defined by the 3 non aligned given points

erf

complex_t xlifepp::erf(complex_t z)

error

template<typename T>
void xlifepp::error(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)

void xlifepp::error(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)

shortcut of msg for error type messages

throw error messages

euler

template<typename T>
Vector<T> xlifepp::euler(T &(*f)(real_t, const T&, T&), real_t a, real_t b, real_t dt, const T &y0)

template<typename T, typename P>
Vector<T> xlifepp::euler(T &(*f)(real_t, const T&, T&, P&), real_t a, real_t b, real_t dt, const T &y0, P &pars)

eval

template<typename K>
std::vector<K> xlifepp::eval(const std::vector<PolynomialT<K>> &p, const K &x1, const K &x2 = K(1), const K &x3 = K(1))

evalContractedProduct

template<>
inline void xlifepp::evalContractedProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalContractedProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

Contracted product.

evalCrossProduct

template<>
inline void xlifepp::evalCrossProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res, bool right)

template<typename T, typename R>
void xlifepp::evalCrossProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res, bool right)

Cross product.

evalFun

inline complex_t xlifepp::evalFun(SymbolicOperation op, const complex_t &z, const complex_t &p = 0.)

inline real_t xlifepp::evalFun(SymbolicOperation op, const real_t &x, const real_t &p = 0.)

evalInnerProduct

template<>
inline void xlifepp::evalInnerProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
void xlifepp::evalInnerProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

Inner product.

evalMatrixMatrixProduct

template<>
inline void xlifepp::evalMatrixMatrixProduct(const Matrix<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalMatrixMatrixProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

evalMatrixMatrixProduct2

template<>
inline void xlifepp::evalMatrixMatrixProduct2(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalMatrixMatrixProduct2(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

evalMatrixVectorProduct

template<>
inline void xlifepp::evalMatrixVectorProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalMatrixVectorProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

Matrix product.

template<>
inline void xlifepp::evalMatrixVectorProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalMatrixVectorProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

Matrix product using vector representation of matrix.

evalOp

inline complex_t xlifepp::evalOp(SymbolicOperation op, const complex_t &x, const complex_t &y)

inline real_t xlifepp::evalOp(SymbolicOperation op, const real_t &x, const real_t &y)

evalScalarProduct

template<>
inline void xlifepp::evalScalarProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalScalarProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

template<>
inline void xlifepp::evalScalarProduct(const real_t &val, const Vector<complex_t> &v, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalScalarProduct(const T &val, const Vector<R> &v, Vector<T> &res)

Product by a scalar.

template<>
inline void xlifepp::evalScalarProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalScalarProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

evalVectorMatrixProduct

template<>
inline void xlifepp::evalVectorMatrixProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalVectorMatrixProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

template<>
inline void xlifepp::evalVectorMatrixProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)

template<typename T, typename R>
inline void xlifepp::evalVectorMatrixProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)

exp

inline SuTermVector xlifepp::exp(const SuTermVector &s)

inline SymbolicFunction &xlifepp::exp(const SymbolicFunction &f)

inline TermVector xlifepp::exp(const TermVector &s)

expand

GeoNode xlifepp::expand(const GeoNode &gn)

create the expansion of a GeoNode (new object)

create the expansion of a GeoNode

expzE1z

complex_t xlifepp::expzE1z(const complex_t&)

return exp(z)*E1(z)

ext_Fock_s

complex_t xlifepp::ext_Fock_s(real_t x, Parameters &pars)

ext_Fock_s_app

complex_t xlifepp::ext_Fock_s_app(real_t x, Parameters &pars)

extendStorage

void xlifepp::extendStorage(MatrixEntry *mat, std::vector<DofComponent> &cdofsr, std::vector<DofComponent> &cdofsc, const Constraints *cu, const Constraints *cv, bool keepSymmetry, bool doRow, bool doCol, bool doDiag, bool doPenal)

extend storage of matrix when constraints are not local and have column/row combination, assuming scalar matrix entries ! mat: pointer to the matrix to be reduced cdofsr: row dof components cdofsc: col dof components cu: pointer to the constraints on the unknown u (col) cv: pointer to the constraints on test function v (row) keepSymmetry: flag to indicate to force symmetry of the extended storage (default not keeping symmetry) doRow, doCol, doDiag: flags to indicates which extensions are processed (default all) doPenal: if true, add the pattern of C’C (symmetric penalization, see Constraints::penalizationReduction)

extend matrix storage when constraints are not local and have column/row combination

extendVector

template<typename I1, typename I2>
void xlifepp::extendVector(const std::vector<number_t> &renum, I1 it1, I2 it2)

template extension method

extension

TermVector xlifepp::extension(const Function &f, const Function &g, const GeomDomain &dom, const Unknown &u)

TermVector xlifepp::extension(const Function &f, const Function &g, const GeomDomain &dom, const Unknown &u, const Function &h)

Value xlifepp::extension(const Function &f, const Function &g, const Point &P)

Value xlifepp::extension(const Function &f, const Function &g, const Point &P, const Function &h)

TermVector xlifepp::extension(const TermVector &f, const Function &g, const GeomDomain &dom, const Unknown &u)

TermVector xlifepp::extension(const TermVector &f, const Function &g, const GeomDomain &dom, const Unknown &u, const Function &h)

Value xlifepp::extension(const TermVector &f, const Function &g, const Point &P)

Value xlifepp::extension(const TermVector &f, const Function &g, const Point &P, const Function &h)

extractComponents

template<typename K>
Vector<K> xlifepp::extractComponents(const Vector<Vector<K>> &vov, number_t i)

template<typename K>
void xlifepp::extractComponents(const Vector<Vector<K>> &vov, Vector<K> &v, number_t i)

extract i-th components (i>0) of a Vector<Vector<K> > and store extract values in Vector<K> (index i>0 is not checked!)

extrude

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, const char *domName, const char *sidenames)

definition of a geometry by extrusion of another geometry, with name and side name

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, const char *domName, std::vector<string_t> sidenames = std::vector<string_t>())

definition of a geometry by extrusion of another geometry, with name and side names

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, const std::vector<Parameter> &ps)

main routine for the definition of a geometry by extrusion of another geometry, with a list if parameters

main external routine for the definition of a geometry by extrusion of another geometry, with a list if parameters

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, const char *domName, const char *sidenames)

definition of a geometry by extrusion of another geometry, with name and side name

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, const char *domName, std::vector<string_t> sidenames = std::vector<string_t>())

definition of a geometry by extrusion of another geometry, with name and side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, std::vector<string_t> sidenames = std::vector<string_t>())

definition of a geometry by extrusion of another geometry, with side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, string_t domName, std::vector<string_t> sidenames = std::vector<string_t>())

definition of a geometry by extrusion of another geometry, with name and side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, string_t domName, string_t sidenames)

definition of a geometry by extrusion of another geometry, with name and side name

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p)

Definition of a geometry by extrusion of another geometry, with 1 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2)

Definition of a geometry by extrusion of another geometry, with 2 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3)

Definition of a geometry by extrusion of another geometry, with 3 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3, Parameter p4)

Definition of a geometry by extrusion of another geometry, with 4 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3, Parameter p4, Parameter p5)

Definition of a geometry by extrusion of another geometry, with 5 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3, Parameter p4, Parameter p5, Parameter p6)

Definition of a geometry by extrusion of another geometry, with 6 Parameter.

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, std::vector<string_t> sidenames = std::vector<string_t>())

definition of a geometry by extrusion of another geometry, with side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, string_t domName, std::vector<string_t> sidenames = std::vector<string_t>())

definition of a geometry by extrusion of another geometry, with name and side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, string_t domName, string_t sidenames)

definition of a geometry by extrusion of another geometry, with name and side name

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p)

extrude a mesh using a list of transformations

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2, const Parameter &p3)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const std::vector<Parameter> &ps)

external routine to apply an extrusion on a Mesh using a list of transformation

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p)

extrude a mesh using a transformation

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2, const Parameter &p3)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const std::vector<Parameter> &ps)

external routine to apply an extrusion on a Mesh using an elementary transformation

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p)

extrude a mesh using a parametrization function

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2, const Parameter &p3)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const std::vector<Parameter> &ps)

external routine to apply an extrusion on a Mesh using a parametrisation function

eyeMatrix

template<typename K>
void xlifepp::eyeMatrix(MatrixEigenDense<K> &mat)

Reverse all elements of a matrix.

faceNumbering

template<class ST_>
number_t *xlifepp::faceNumbering()

Termination of the construction of a mesh object of 3D elements by transferring data from a subdivision::xxxMesh object into XLiFE++ objects.

factLeftSolve

VectorEntry xlifepp::factLeftSolve(MatrixEntry&, const VectorEntry&)

solve transposed linear system after factorization method

TermVectors xlifepp::factLeftSolve(TermMatrix &A, const std::vector<TermVector> &Bs)

solve left linear system Xs*A=b (~ At*Xs=B) with multiple right hand sides when matrix is already factorized B may be a TermVectors

TermVector xlifepp::factLeftSolve(TermMatrix &A, const TermVector &B)

solve left linear system X*A=b (~ At*X=B) when matrix is already factorized

TermMatrix xlifepp::factLeftSolve(TermMatrix &A, TermMatrix &B)

solve left linear system with TermMatrix as right hand side when matrix is already factorized return a TermMatrix in column dense storage

factorize

void xlifepp::factorize(MatrixEntry &A, FactorizationType ft, bool withPermutation)

factorize matrix as LU or LDLt or LDL*, not preserving A

factorize matrix as LU or LDLt or LDL*

void xlifepp::factorize(MatrixEntry &A, MatrixEntry &Af, FactorizationType ft, bool withPermutation)

factorize matrix as LU or LDLt or LDL* along matrix property if ft=_noFactorisation, type of factorization is searched if matrix is symmetric ldlt factorisation is used if matrix is self-adjoint ldlstar factorisation is used note that factorisation may be failed because there is no pivoting strategy (except for definite symmetric matrix!) if matrix is skew-adjoint ldlstar factorisation may be worked if the diagonal is non zero if matrix is skew-symmetric (diagonal is zero!) ldlt failed in any case ! For the moment LU factorisation is used in case of a skew-adjoint or a skew-symmetric matrix in future, for specific algorithm for skew symmetric or skew adjoint matrices see following papers: Bunch J.R.

factorize matrix as LU or LDLt or LDL*

Stable Algorithms for Solving Symmetric and Skew-Symmetric Systems, Bull. Austral. Math. Soc., vol 26, 107-119, 1982 Lau T., Numerical Solution of Skew-Symmetric Linear Systems, Master Thesis, University of British Columbia, 2007

If umfPack is available, it is used when ft is not specified if withPermution = true, LU with row permutation will be used to deal with dense matrices

void xlifepp::factorize(SuTermMatrix&, FactorizationType ft = _noFactorization, bool withPermutation = true)

factorize matrix as LU or LDLt or LDL*

void xlifepp::factorize(SuTermMatrix&, SuTermMatrix&, FactorizationType ft = _noFactorization, bool withPermutation = true)

factorize matrix as LU or LDLt or LDL*

void xlifepp::factorize(TermMatrix &A, FactorizationType ft, bool withPermutation)

factorize matrix as LU or LDLt or LDL*, not preserving A

void xlifepp::factorize(TermMatrix &A, TermMatrix &Af, FactorizationType ft, bool withPermutation)

factSolve

VectorEntry xlifepp::factSolve(MatrixEntry&, const VectorEntry&)

solve linear system after factorization method

SuTermVector xlifepp::factSolve(SuTermMatrix&, const SuTermVector&)

solve AX=B when A is factorized

SuTermVectors xlifepp::factSolve(SuTermMatrix &A, const std::vector<SuTermVector> &Bs)

solve linear system with multiple right hand sides when matrix is already factorized Bs may be a SuTermVectors

solve AXs=Bs when A is factorized

SuTermMatrix xlifepp::factSolve(SuTermMatrix &A, SuTermMatrix &B)

solve linear system with right hand side matrix when matrix is already factorized in other words create the matrix C = inv(A) * B, C is stored in a dense format Works on scalar representation !

create inv(A)*B when A is factorized

TermVectors xlifepp::factSolve(TermMatrix &A, const std::vector<TermVector> &Bs)

solve linear system with multiple right hand sides when matrix is already factorized B may be a TermVectors

TermVector xlifepp::factSolve(TermMatrix &A, const TermVector &B)

TermMatrix xlifepp::factSolve(TermMatrix &A, TermMatrix &B)

solve linear system with TermMatrix as right hand side when matrix is already factorized return a TermMatrix in column dense storage

ferrari

std::vector<complex_t> xlifepp::ferrari(real_t a, real_t b, real_t c, real_t d, real_t e)

computes roots of degree 4 polynomial (Ferrari method)

fft

template<typename T>
std::vector<complex_t> xlifepp::fft(const std::vector<T> &f)

template<typename T>
std::vector<complex_t> &xlifepp::fft(const std::vector<T> &f, std::vector<complex_t> &g)

template<typename IterA, typename IterB>
void xlifepp::fft(IterA ita, IterB itb, number_t log2n)

perform the discrete Fourier transform of the discrete vector a of length n=2^log2n the result is the vector b of length 2^log2n bk = sum_j=0,n-1 aj*exp(-2*i*pi*j*k/n) ita: iterator at the beginning of a itb: iterator at the beginning of b log2n: log_2(n)

ffta

template<typename IterA, typename IterB>
void xlifepp::ffta(IterA ita, IterB itb, number_t log2n, real_t q)

perform the discrete Fourier transform of the discrete vector a of length n=2^log2n the result is the vector b of length 2^log2n bk = sum_j=0,n-1 aj*exp(2*i*q*j*k/n) ita: iterator at the beginning of a itb: iterator at the beginning of b log2n: log_2(n) q: a parameter = -pi for direct fft and = pi for inverse fft

fileExtension

string_t xlifepp::fileExtension(const string_t &f)

return file name extension using last point as delimiter return root file name and file name extension using last point as delimiter

fileNameFromComponents

inline string_t xlifepp::fileNameFromComponents(const string_t &rootname, const string_t &extension)

string_t xlifepp::fileNameFromComponents(const string_t &rootname, const string_t &suffix, const string_t &extension)

build filename from rootname with an additionnal suffix, and extension: rootname_suffix.extension

fileRootExtension

std::pair<string_t, string_t> xlifepp::fileRootExtension(const string_t &f, const std::vector<string_t> &authorizedExtensions)

fileWithoutExtension

string_t xlifepp::fileWithoutExtension(const string_t &f)

return file name without extension using last point as delimiter

filon_f

inline complex_t xlifepp::filon_f(real_t t, Parameters &pa = defaultParameters)

function used in Filon: 1/(w2’(r*(t+s))-qw2(r*(t+s))) where s is a shift and r a complex rotation

finalize

void xlifepp::finalize()

finalize execution of XLiFE++

findBestQuadrature

Quadrature *xlifepp::findBestQuadrature(ShapeType, number_t, bool = false)

“ersatz” of constructor (find or create a new quadrature rule)

findBorder

int_t xlifepp::findBorder(const std::pair<ShapeType, std::vector<const Point*>> &border, const std::vector<std::pair<ShapeType, std::vector<const Point*>>> &borders)

find if a curve/surf is in a list of curves/surfs

findDifferentialOperator

DifferentialOperator *xlifepp::findDifferentialOperator(DiffOpType)

contructor-like, returns newly created or existing object

findGeomRefElement

GeomRefElement *xlifepp::findGeomRefElement(ShapeType shape)

GeomRefElementFind definition of a Geom Reference Element by shape number use existing Geom Reference Element object if one already exists otherwise create a new one, in both cases returns pointer to the object.

definition of a Geom Reference Element by shape type use existing Geom Reference Element if one exists, otherwise create a new one, in both cases returns pointer to the object

findId

short int xlifepp::findId(std::vector<CrackData>::const_iterator it_b, std::vector<CrackData>::const_iterator it_e, number_t id)

finds a crack data in a list

short int xlifepp::findId(std::vector<PhysicalData>::const_iterator it_b, std::vector<PhysicalData>::const_iterator it_e, number_t id)

finds a physical data in a list

findInterpolation

Interpolation *xlifepp::findInterpolation(FEType typ, FESubType sub, number_t num, SobolevType spa)

return Interpolation defined by its characteristics use existing Interpolation object if one already exists otherwise create a new one, in both cases returns pointer to the object

main “constructor” by finding first if already exists

Interpolation *xlifepp::findInterpolation(InterpolationType interpType, number_t dim)

main “constructor” by finding first if already exists

findMap

const Function *xlifepp::findMap(const GeomDomain&, const GeomDomain&)

find map between 2 geomdomains

findMatrixStorage

MatrixStorage *xlifepp::findMatrixStorage(const string_t &id, StorageType st, AccessType at)

find matrix storage in vector theMatrixStorages of class MatrixStorage

MatrixStorage *xlifepp::findMatrixStorage(const string_t &id, StorageType st, AccessType at, StorageBuildType sb, bool scalar, number_t nbr, number_t nbc)

findProjector

Projector &xlifepp::findProjector(Space &V, dimen_t nbcV, Space &W, dimen_t nbcW, ProjectorType pt = _L2Projector)

findQuadrature

Quadrature *xlifepp::findQuadrature(ShapeType, QuadRule, number_t, bool = false)

“ersatz” of constructor (find or create a new quadrature rule)

findRefElement

RefElement *xlifepp::findRefElement(ShapeType shape, const Interpolation *interp_p)

definition of a Reference Element by shape number and interpolation use existing Reference Element object if one already exists otherwise create a new one, in both cases returns pointer to the object

RefElementFind definition of a Reference Element by shape number and interpolation use existing Reference Element object if one already exists otherwise create a new one, in both cases returns pointer to the object.

findString

int_t xlifepp::findString(const string_t, const std::vector<string_t>&)

returns position of string in vector<string>

short int xlifepp::findString(std::vector<PhysicalData>::const_iterator it_b, std::vector<PhysicalData>::const_iterator it_e, string_t name)

finds a physical data in a list

findUnknown

Unknown *xlifepp::findUnknown(const string_t&)

find Unknown in list of Unknown

fockCurvatureTransition_D

complex_t xlifepp::fockCurvatureTransition_D(real_t x)

fockCurvatureTransition_N

complex_t xlifepp::fockCurvatureTransition_N(real_t x)

force3D

Point xlifepp::force3D(const Point &p)

extends a copy of a point to a 3D point

returns a 3-components copy of a point

format

string_t xlifepp::format(const string_t &s, number_t l, Alignment = _centerAlignment)

format string at size s with alignment option

foundParent

bool xlifepp::foundParent(const vector<number_t> &nums, const SIDELTMAP &parentEl, ITPARENTS &itpar)

fromUnknownVal

template<typename T>
OperatorOnUnknown &xlifepp::fromUnknownVal(const Unknown &un, const T &val, AlgebraicOperator aop)

fromValUnknown

template<typename T>
OperatorOnUnknown &xlifepp::fromValUnknown(const Unknown &un, const T &val, AlgebraicOperator aop)

fun_EC_SC

complex_t xlifepp::fun_EC_SC(const Point &P, Parameters &pars)

fun_EC_SR

real_t xlifepp::fun_EC_SR(const Point &P, Parameters &pars)

fun_EC_VC

Vector<complex_t> xlifepp::fun_EC_VC(const Point &P, Parameters &pars)

fun_EC_VR

Vector<real_t> xlifepp::fun_EC_VR(const Point &P, Parameters &pars)

fun_productC

inline complex_t xlifepp::fun_productC(const complex_t &x, const complex_t &y)

fun_productR

inline real_t xlifepp::fun_productR(const real_t &x, const real_t &y)

gammaFunction

complex_t xlifepp::gammaFunction(const complex_t&)

return \(\int_0^t dt t^{x-1} \exp(-t)\) for x > 0

real_t xlifepp::gammaFunction(int_t n)

Function \(Gamma(z) = \int_0^{\infty} t^{z-1} exp(-t) dt for Re(z) > 0\).

• Gamma(1-z) = Pi / ( sin(Pi z) Gamma(z) )

• Gamma(z+1) = z Gamma(z)

• Gamma(n+1) = n! for integer n > 0 return Gamma(n) = (n-1)!

real_t xlifepp::gammaFunction(real_t)

return \(\int_0^t dt t^{x-1} \exp(-t)\) for x > 0

gammaTest

void xlifepp::gammaTest(std::ostream &out)

gaussJacobi20Output

void xlifepp::gaussJacobi20Output(number_t nmax, std::ostream &out)

Output of Gauss-Jacobi (2,0) rule as displayed in function GaussJacobi20Rule.

“tabulated output” of Gauss-Jacobi (2,0) rules up to a given number of points

gaussJacobi20Rule

void xlifepp::gaussJacobi20Rule(number_t n, std::vector<real_t> &points, std::vector<real_t> &weights)

Compute Gauss-Jacobi n-point formula on [-1, 1] for the weight (1-x)^2.

returns Gauss-Jacobi (2,0) rule with tabulated

• Points xj are roots of Jacobi Polynomial Pn(2,0) of ordre n

• Weights are 8/((1-xi^2)*Pn(2,0)’(xi)^2) (see gaussJacobiRuleComputed)

• tabulated values for n<=10, computed values for n>10 (nothing was done for n>10 before)

Note: the n points are returned in ascending order, points and weights are resized to n.

gaussJacobiOutput

void xlifepp::gaussJacobiOutput(number_t nmax, real_t a, real_t b, std::ostream &out)

Output of Gauss-Jacobi rule as displayed in function GaussJacobi20Rule.

“tabulated output” of Gauss-Jacobi rules up to a given number of points

gaussJacobiRule

void xlifepp::gaussJacobiRule(number_t n, real_t a, real_t b, std::vector<real_t> &points, std::vector<real_t> &weights)

Compute Gauss-Jacobi n-point formula on [-1, 1] for the weight (1-x)^a*(1+x)^b, a>-1, b>-1.

returns Gauss-Jacobi rule with tabulated

• Points xj are roots of Jacobi Polynomial Pn(a,b) of ordre n (namely orthogonal polynomials of weight (1-x)^a*(1+x)^b)

• Weights are 2^(a+b+1)*Gamma(n+a+1)*Gamma(n+b+1)/(Gamma(n+a+b+1)*n!*(1-xi^2)*Pn(a,b)’(xi)^2)

• exact for polynomials of degree 2n-1 (times the weight)

Note: a=b=0 is the Gauss-Legendre rule (gaussLegendreRule), a=2, b=0 uses tabulated values up to n=10, the n points are returned in ascending order

gaussJacobiRuleComputed

static void xlifepp::gaussJacobiRuleComputed(number_t n, real_t a, real_t b, std::vector<real_t> &points, std::vector<real_t> &weights)

Compute Gauss-Jacobi n-point formula on [-1, 1] for any n, a>-1, b>-1 (weight (1-x)^a*(1+x)^b)

• points: eigenvalues of the symmetric tridiagonal Jacobi matrix (bisection with Sturm sequences), ascending order

• weights: 2^(a+b+1)*Gamma(n+a+1)*Gamma(n+b+1)/(Gamma(n+a+b+1)*n!*(1-xi^2)*Pn(a,b)’(xi)^2) with Pn(a,b)’ = (n+a+b+1)/2*P(n-1)(a+1,b+1)

gaussLegendreOutput

void xlifepp::gaussLegendreOutput(number_t nmax, std::ostream &out)

Output of Gauss-Legendre rule as displayed in function GaussLegendreRule.

“tabulated output” of Gauss-Lobatto rules up to a given number of points

gaussLegendreRule

void xlifepp::gaussLegendreRule(number_t n, std::vector<real_t> &points, std::vector<real_t> &weights)

returns quadrature points and weights for Gauss-Legendre formula for a given number of points n; n-point Gauss-Legendre formula is exact for polynomials of degree up to {2n-1} on [-1,1].

returns Gauss-Legendre rule with computed or tabulated

Points and weights are given below for n up to 16

Note: the (n+1)/2 positive points in ascending order only are returned.

gaussLegendreRuleComputed

void xlifepp::gaussLegendreRuleComputed(number_t n, std::vector<real_t> &points, std::vector<real_t> &weights)

Compute Gauss-Legendre n-point formula on [-1, 1].

returns Gauss-Legendre rule for any number of points

• Points xj are roots of Legendre Polynomial pn of ordre n

• Weights are 2/( (1-xj^2) (P’_n(xj)^2) )

Note: the (n+1)/2 first positive points in ascending order only are returned.

gaussLobattoOutput

void xlifepp::gaussLobattoOutput(number_t nmax, std::ostream &out)

Output of Gauss-Lobatto rule as displayed in function GaussLobattoRule.

“tabulated output” of Gauss-Lobatto rules up to a given number of points

gaussLobattoPoints

void xlifepp::gaussLobattoPoints(number_t n, std::vector<real_t> &points)

returns quadrature nodes for Gauss-Lobatto rule for a given number of points.

returns Gauss-Lobatto points for any number of points

Note: the (n+1)/2 points non-negative points in ascending order are returned only with possible point 0 included and including end point 1

gaussLobattoRule

void xlifepp::gaussLobattoRule(number_t n, std::vector<real_t> &points, std::vector<real_t> &weights)

returns quadrature points & weights for Gauss-Lobatto rule for a given number of points.

returns Gauss-Lobatto rule with computed or tabulated

n-point Gauss-Lobatto formula is exact for P_{2n-3}(0,1)

Note: only points and weights corresponding to the (n+1)/2 points non-negative points, with possible point 0 included and including end point 1, are returned

The following programs shows table of values (with 20 significant digits) up to n=16 which have been computed by function GaussLobattoRuleComputed using type long double.

gaussLobattoRuleComputed

void xlifepp::gaussLobattoRuleComputed(number_t n, std::vector<real_t> &points, std::vector<real_t> &weights)

compute Gauss-Lobatto n-point formula on [-1, 1] end points included

returns Gauss-Lobatto rule for any number of points

• Points xj are roots of (1-x^2)*P’_{n-1} with P’_{n-1} derivative of Legendre Polynomial of ordre n-1

• Weights are 2./(n*(n-1)) for end points -1 and +1 2./(n*(n-1)*{P_{n-1}(xj)}^2) for other xj

Note: the (n-1)/2 first positive points in ascending order only are returned that is excluding end point 1 and corresponding weight.

gaussMultipleSolver

template<typename K_>
bool xlifepp::gaussMultipleSolver(std::vector<K_> &mat, std::vector<K_> &rhs, number_t nbrhs, real_t &minPivot, number_t &row)

Template multiple Gaussian elimination solver with partial pivoting strategy for a square linear system with dense row major access matrix the number of right hand sides is given by nbrhs Note: when giving Id matrix as rhs, it returns the inverse of mat in rhs.

gaussSolve

template<typename T>
void xlifepp::gaussSolve(LargeMatrix<T> &mat, std::vector<std::vector<T>> &rhss)

template<typename T>
void xlifepp::gaussSolve(LargeMatrix<T> &mat, std::vector<T> &rhs)

void xlifepp::gaussSolve(MatrixEntry&, VectorEntry&, VectorEntry&)

Gauss solver (only in scalar representation)

SuTermVector xlifepp::gaussSolve(SuTermMatrix&, const SuTermVector&, bool keepA = false)

solve AX=B using Gauss reduction solve AX=B using umfpack if available

TermVectors xlifepp::gaussSolve(TermMatrix &A, const std::vector<TermVector> &Bs, bool keepA)

TermVector xlifepp::gaussSolve(TermMatrix &A, const TermVector &B, bool keepA)

gaussSolver

template<typename K_>
bool xlifepp::gaussSolver(std::vector<K_> &mat, std::vector<K_> &rhs, real_t &minPivot, number_t &row)

Template Gaussian elimination solver with partial pivoting strategy for a square linear system with dense row major access matrix.

gcdNumber

static number_t xlifepp::gcdNumber(number_t a, number_t b)

greatest common divisor

gegenbauerPolynomials

void xlifepp::gegenbauerPolynomials(real_t lambda, real_t, std::vector<real_t>&)

Gegenbauer ultraspherical polynomials on [-1, 1], with parameter lambda up to order n P_0 = 1, P_1 = 2*lambda*x n*P_n(x) = 2*(n+lambda-1)*x*P_{n-1}(x) - (n+2*lambda-2)*P_{n-2}(x) , n > 1.

genDomName

string_t xlifepp::genDomName(number_t ndom)

string_t xlifepp::genDomName(number_t ndom, const map<number_t, string_t> &domNameMap)

genDomName2

string_t xlifepp::genDomName2(number_t ndom, number_t nbdoms)

genSDomName

string_t xlifepp::genSDomName(number_t ndom, number_t nsdom)

string_t xlifepp::genSDomName(number_t ndom, number_t nsdom, const map<number_t, string_t> &domNameMap)

genSDomName2

string_t xlifepp::genSDomName2(number_t ndom, number_t nsdom, number_t nbdoms)

geomElementFromParameters

inline const GeomElement *xlifepp::geomElementFromParameters(Parameters &pars)

geomUnionOf

const GeomDomain *xlifepp::geomUnionOf(std::vector<const GeomDomain*> &doms, const GeomDomain *largeDom)

construct or identify the geometrical union of domains.

construct or identify the geometrical symbolic union of domains

Geometrical union is a real union which performs element or side element inclusion in other elements or side elements it uses the element id number to test inclusion of a list of elements in an other list of elements for side element it uses the parent element id number. !!! Side of side element is not handled for the moment

largeDom is a large domain containing all domains given in doms

GeomDomains may be a meshDomain or a compositeDomain of union type (domains intersection are not managed) when a domain contains all others, the function returns it when the union gives an existing domain, the function returns it else the function return a new compositeDomain (union)

Note

do not confuse geometrical union with union of domains which is a semantic union (no geometrical analysis is performed) Geometrical union is an internal tool, end users do not have to use it

get_value_type

ValueType xlifepp::get_value_type(const string_t&)

get the type of the parameter value by name

getB

inline Vector<real_t> &xlifepp::getB()

inline Vector<real_t> &xlifepp::getB(number_t t)

getBasisIndex

inline number_t xlifepp::getBasisIndex()

inline number_t xlifepp::getBasisIndex(number_t t)

getBx

inline Vector<real_t> &xlifepp::getBx()

inline Vector<real_t> &xlifepp::getBx(number_t t)

getBy

inline Vector<real_t> &xlifepp::getBy()

inline Vector<real_t> &xlifepp::getBy(number_t t)

getComponentBordersToGeo

Strings xlifepp::getComponentBordersToGeo(const Geometry &g)

returns the borders numbers of a canonical geometry in a geo file

writing the borders numbers of a canonicl geometry in a geo file

getDerivative

inline number_t xlifepp::getDerivative()

inline number_t xlifepp::getDerivative(number_t t)

getDof

inline Dof &xlifepp::getDof()

inline Dof &xlifepp::getDof(number_t t)

getDomain

inline GeomDomain &xlifepp::getDomain()

getDomainx

inline GeomDomain &xlifepp::getDomainx()

getDomainy

inline GeomDomain &xlifepp::getDomainy()

getElement

inline GeomElement &xlifepp::getElement()

inline GeomElement &xlifepp::getElement(number_t t)

getElementP

inline GeomElement *xlifepp::getElementP()

inline GeomElement *xlifepp::getElementP(number_t t)

getFeDof

inline FeDof &xlifepp::getFeDof()

inline FeDof &xlifepp::getFeDof(number_t t)

getImpl

template<class T>
inline DefaultSPStorage<T>::PointerType xlifepp::getImpl(const DefaultSPStorage<T> &sp)

getImplConstRef

template<class T>
inline const DefaultSPStorage<T>::StoredType &xlifepp::getImplConstRef(DefaultSPStorage<T> &sp)

getImplRef

template<class T>
inline const DefaultSPStorage<T>::StoredType &xlifepp::getImplRef(const DefaultSPStorage<T> &sp)

template<class T>
inline DefaultSPStorage<T>::StoredType &xlifepp::getImplRef(DefaultSPStorage<T> &sp)

getMaterialId

inline number_t xlifepp::getMaterialId()

number_t xlifepp::getMaterialId(number_t t)

get the material id of GeomElement managed by thread t

getN

inline Vector<real_t> &xlifepp::getN()

inline Vector<real_t> &xlifepp::getN(number_t t)

getNormalVectorFrom

inline const Vector<real_t> &xlifepp::getNormalVectorFrom(const Parameters &pa)

getNx

inline Vector<real_t> &xlifepp::getNx()

inline Vector<real_t> &xlifepp::getNx(number_t t)

getNxVectorFrom

inline const Vector<real_t> &xlifepp::getNxVectorFrom(const Parameters &pa)

getNy

inline Vector<real_t> &xlifepp::getNy()

inline Vector<real_t> &xlifepp::getNy(number_t t)

getNyVectorFrom

inline const Vector<real_t> &xlifepp::getNyVectorFrom(const Parameters &pa)

getRefCounted

template<typename T>
inline const RefCounted<T>::CountType &xlifepp::getRefCounted(const RefCounted<T> &ref)

template<typename T>
inline RefCounted<T>::CountType &xlifepp::getRefCounted(RefCounted<T> &ref)

getRefCountedAlloc

template<typename T>
bool xlifepp::getRefCountedAlloc(RefCounted<T> &ref)

getRefElt

RefElement *xlifepp::getRefElt(number_t elmType, const GMSHMAP &gmMap, number_t *nb_pts, number_t *elmDim, bool *isSimplex)

getT

inline Vector<real_t> &xlifepp::getT()

inline Vector<real_t> &xlifepp::getT(number_t t)

getTx

inline Vector<real_t> &xlifepp::getTx()

inline Vector<real_t> &xlifepp::getTx(number_t t)

getTy

inline Vector<real_t> &xlifepp::getTy()

inline Vector<real_t> &xlifepp::getTy(number_t t)

getVector

inline Vector<real_t> &xlifepp::getVector(UnitaryVector un)

grad

template<typename K>
std::vector<PolynomialT<K>> xlifepp::grad(const MonomialT<K> &m, dimen_t d = 3)

template<typename K>
PolynomialsBasisT<K> xlifepp::grad(const PolynomialBasisT<K> &ps)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::grad(const PolynomialT<K> &p, dimen_t d = 3)

OperatorOnUnknown &xlifepp::grad(const Unknown &un)

grad_x

OperatorOnKernel &xlifepp::grad_x(const Kernel&)

grad_x(k)

OperatorOnKernel &xlifepp::grad_x(OperatorOnKernel&)

grad_x(opk)

grad_y

OperatorOnKernel &xlifepp::grad_y(const Kernel&)

grad_y(k)

OperatorOnKernel &xlifepp::grad_y(OperatorOnKernel&)

grad_y(opk)

gradG

OperatorOnUnknown &xlifepp::gradG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)

gradS

OperatorOnUnknown &xlifepp::gradS(const Unknown &un)

gradxgradyover4pir

void xlifepp::gradxgradyover4pir(const Point&, const Point&, Vector<Vector<real_t>>&)

\(grad_xgrad_y/(4\pi r)\)

gradxover4pir

void xlifepp::gradxover4pir(const Point&, const Point&, Vector<real_t>&)

\(grad_x/(4\pi r)\)

hankelH1

inline complex_t xlifepp::hankelH1(const complex_t &z, real_t N)

Hankel function of the first kind and order N: H1_N(z) = J_N(z) + i Y_N(z) (complex case)

template<>
inline complex_t xlifepp::hankelH1(real_t x, real_t N)

Hankel function of the first kind and real order N: H1_N(x) = J_N(x) + i Y_N(x)

template<class T_>
complex_t xlifepp::hankelH1(real_t x, T_ N)

hankelH10

inline complex_t xlifepp::hankelH10(const complex_t &z)

Hankel function of the first kind and order 0 : H1_0(z) = J_0(z) + i Y_0(z) (complex case)

complex_t xlifepp::hankelH10(real_t x)

Hankel function of the first kind and order 0 : H1_0(x) = J_0(x) + i Y_0(x)

hankelH10N

std::vector<complex_t> xlifepp::hankelH10N(real_t x, number_t N)

Hankel functions of the first kind and order 0 … N: H1_k(x) = J_k(x) + i Y_k(x)

hankelH11

inline complex_t xlifepp::hankelH11(const complex_t &z)

Hankel function of the first kind and order 1 : H1_1(z) = J_1(z) + i Y_1(z) (complex case)

complex_t xlifepp::hankelH11(real_t x)

Hankel function of the first kind and order 1 : H1_1(x) = J_1(x) + i Y_1(x)

hankelH2

inline complex_t xlifepp::hankelH2(const complex_t &z, real_t N)

Hankel function of the second kind and order N: H2_N(z) = J_N(z) - i Y_N(z) (complex case)

template<>
inline complex_t xlifepp::hankelH2(real_t x, real_t N)

Hankel function of the second kind and real order N: H2_N(x) = J_N(x) - i Y_N(x)

template<class T_>
complex_t xlifepp::hankelH2(real_t x, T_ N)

hankelH20

inline complex_t xlifepp::hankelH20(const complex_t &z)

Hankel function of the second kind and order 0 : H2_0(z) = J_0(z) + i Y_0(z) (complex case)

inline complex_t xlifepp::hankelH20(real_t x)

Hankel function of the second kind and order 0 : H2_0(x) = J_0(x) - i Y_0(x)

hankelH20N

std::vector<complex_t> xlifepp::hankelH20N(real_t x, number_t N)

Hankel functions of the second kind and order 0 … N: H2_k(x) = J_k(x) - i Y_k(x)

hankelH21

inline complex_t xlifepp::hankelH21(const complex_t &z)

Hankel function of the second kind and order 1 : H2_1(z) = J_1(z) - i Y_1(z) (complex case)

inline complex_t xlifepp::hankelH21(real_t x)

Hankel function of the second kind and order 1 : H2_1(x) = J_1(x) - i Y_1(x)

hasAnalyticGeodesic

bool xlifepp::hasAnalyticGeodesic(const Geometry &geo)

hasCommonElts

template<typename T>
bool xlifepp::hasCommonElts(const ClusterNode<T> &cn1, const ClusterNode<T> &cn2)

hasGeometricGeodesic

bool xlifepp::hasGeometricGeodesic(const Geometry &geo)

height

inline real_t xlifepp::height(const Point &A, const Point &B, const Point &C)

Helmholtz2d

complex_t xlifepp::Helmholtz2d(const Point &x, const Point &y, Parameters &pa = defaultParameters)

value

Helmholtz2dGradx

Vector<complex_t> xlifepp::Helmholtz2dGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradx

Helmholtz2dGradxReg

Vector<complex_t> xlifepp::Helmholtz2dGradxReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

reg gradx

Helmholtz2dGradxSing

Vector<complex_t> xlifepp::Helmholtz2dGradxSing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

sing gradx

Helmholtz2dGradxy

Matrix<complex_t> xlifepp::Helmholtz2dGradxy(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradxy

Helmholtz2dGradxyReg

Matrix<complex_t> xlifepp::Helmholtz2dGradxyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

reg gradxy

Helmholtz2dGradxySing

Matrix<complex_t> xlifepp::Helmholtz2dGradxySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

sing gradxy

Helmholtz2dGrady

Vector<complex_t> xlifepp::Helmholtz2dGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)

grady

Helmholtz2dGradyReg

Vector<complex_t> xlifepp::Helmholtz2dGradyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

reg grady

Helmholtz2dGradySing

Vector<complex_t> xlifepp::Helmholtz2dGradySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

sing grady

Helmholtz2dHalfPlane

complex_t xlifepp::Helmholtz2dHalfPlane(const Point &x, const Point &y, Parameters &pa = defaultParameters)

Helmholtz kernel in a half-plane with either Dirichlet or Neumann boundary condition half plane P is defined by AY.n >0 where A(a1,a2) is a point of a line L, t = (t1,t2) the tangent vector and n=(-t2,t1) kernel is built from source image Ys = 2A - Y +2*(AY.t)t/|t|^2.

 Hd(X,Y) = H(X,Y) - H(X,Ys)   satisfy Hd(X,Y) =0 for Y in L (say Dirichlet condition)
 Hd(X,Y) = H(X,Y) + H(X,Ys)   satisfy grad(Hd(X,Y)).n =0 for Y in L (say Neumann condition)

Note that dy1(Ys1) = -1+2*t1^2/|t|^2 dy2(Ys1) = 2*t1*t2/|t|^2 dy1(Ys2) = 2*t1^2/|t|^2 dy2(Ys2) = -1 + 2*t2^2/|t|^2

This kernel manage the following parameters bc: boundary condition type on line L (_Dirichlet (default),_Neumann) k: wave number a,b: origin of the line (default (0,0)) t1,t2 : tangent vector of the line (default (1,0))

Helmholtz2dHalfPlaneGradx

Vector<complex_t> xlifepp::Helmholtz2dHalfPlaneGradx(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dHalfPlaneGradxy

Matrix<complex_t> xlifepp::Helmholtz2dHalfPlaneGradxy(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dHalfPlaneGrady

Vector<complex_t> xlifepp::Helmholtz2dHalfPlaneGrady(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dHalfPlaneKernel

Kernel xlifepp::Helmholtz2dHalfPlaneKernel(Parameters& = defaultParameters)

construct a Helmholtz2dHalfPlane kernel

Kernel xlifepp::Helmholtz2dHalfPlaneKernel(real_t k, const std::vector<real_t> &t = Point(1., 0.), const Point &A = Point(0., 0.), BoundaryConditionType bct = _Dirichlet)

construct a Helmholtz2dHalfPlane kernel from k, point, vector, bc

Kernel xlifepp::Helmholtz2dHalfPlaneKernel(real_t k, real_t t1 = 1., real_t t2 = 0., real_t a = 0., real_t b = 0., BoundaryConditionType bct = _Dirichlet)

construct a Helmholtz2dHalfPlane kernel from from k, point, vector, bc

Helmholtz2dHalfPlaneNxdotGradx

complex_t xlifepp::Helmholtz2dHalfPlaneNxdotGradx(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dHalfPlaneNydotGrady

complex_t xlifepp::Helmholtz2dHalfPlaneNydotGrady(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dKernel

Kernel xlifepp::Helmholtz2dKernel(const real_t &k)

construct a Helmholtz2d kernel from real k

Kernel xlifepp::Helmholtz2dKernel(Parameters& = defaultParameters)

construct a Helmholtz2d kernel

Helmholtz2dKernelReg

Kernel xlifepp::Helmholtz2dKernelReg(Parameters& = defaultParameters)

construct a Helmholtz2d kernel, regular part

Helmholtz2dKernelSing

Kernel xlifepp::Helmholtz2dKernelSing(Parameters& = defaultParameters)

construct a Helmholtz2d kernel, singular part

Helmholtz2dNxdotGradx

complex_t xlifepp::Helmholtz2dNxdotGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)

nx.gradx

Helmholtz2dNydotGrady

complex_t xlifepp::Helmholtz2dNydotGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)

ny.grady

Helmholtz2dReg

complex_t xlifepp::Helmholtz2dReg(const Point &x, const Point &y, Parameters &pa)

Regular part of Helmholtz2d function i/4 H^{(1)}_0(k*r) - log(k*r)/(2*pi)

reg value

Helmholtz2dSing

complex_t xlifepp::Helmholtz2dSing(const Point &x, const Point &y, Parameters &pa)

Singular part of Helmholtz2d function - log(r)/(2*pi)

sing value

Helmholtz2dStrip

complex_t xlifepp::Helmholtz2dStrip(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dStripDir

complex_t xlifepp::Helmholtz2dStripDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripGradx

Vector<complex_t> xlifepp::Helmholtz2dStripGradx(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dStripGradxDir

Vector<complex_t> xlifepp::Helmholtz2dStripGradxDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripGradxNeu

Vector<complex_t> xlifepp::Helmholtz2dStripGradxNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripGradxy

Matrix<complex_t> xlifepp::Helmholtz2dStripGradxy(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dStripGradxyDir

Matrix<complex_t> xlifepp::Helmholtz2dStripGradxyDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripGradxyNeu

Matrix<complex_t> xlifepp::Helmholtz2dStripGradxyNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripGrady

Vector<complex_t> xlifepp::Helmholtz2dStripGrady(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dStripGradyDir

Vector<complex_t> xlifepp::Helmholtz2dStripGradyDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripGradyNeu

Vector<complex_t> xlifepp::Helmholtz2dStripGradyNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripKernel

Kernel xlifepp::Helmholtz2dStripKernel(BoundaryConditionType bct, real_t k, real_t h = 1., number_t n = 1000, real_t l = -1., real_t e = 1.E-6)

construct a Helmholtz2dStrip kernel from k, h, n, …

Kernel xlifepp::Helmholtz2dStripKernel(Parameters& = defaultParameters)

construct a Helmholtz2d kernel

Helmholtz2dStripNeu

complex_t xlifepp::Helmholtz2dStripNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)

Helmholtz2dStripNxdotGradx

complex_t xlifepp::Helmholtz2dStripNxdotGradx(const Point &x, const Point &y, Parameters &pa)

Helmholtz2dStripNydotGrady

complex_t xlifepp::Helmholtz2dStripNydotGrady(const Point &x, const Point &y, Parameters &pa)

Helmholtz3d

complex_t xlifepp::Helmholtz3d(const Point &x, const Point &y, Parameters &pa = defaultParameters)

value

Helmholtz3dGradx

Vector<complex_t> xlifepp::Helmholtz3dGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradx

Helmholtz3dGradxReg

Vector<complex_t> xlifepp::Helmholtz3dGradxReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradx

Helmholtz3dGradxSing

Vector<complex_t> xlifepp::Helmholtz3dGradxSing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradx

Helmholtz3dGradxy

Matrix<complex_t> xlifepp::Helmholtz3dGradxy(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradxy

Helmholtz3dGradxyReg

Matrix<complex_t> xlifepp::Helmholtz3dGradxyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradxy

Helmholtz3dGradxySing

Matrix<complex_t> xlifepp::Helmholtz3dGradxySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

gradxy

Helmholtz3dGrady

Vector<complex_t> xlifepp::Helmholtz3dGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)

grady

Helmholtz3dGradyReg

Vector<complex_t> xlifepp::Helmholtz3dGradyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

grady

Helmholtz3dGradySing

Vector<complex_t> xlifepp::Helmholtz3dGradySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

grady

Helmholtz3dKernel

Kernel xlifepp::Helmholtz3dKernel(const complex_t &k)

construct a Helmholtz3d kernel from complex k

Kernel xlifepp::Helmholtz3dKernel(const real_t &k)

construct a Helmholtz3d kernel from real k

Kernel xlifepp::Helmholtz3dKernel(Parameters& = defaultParameters)

construct a Helmholtz3d kernel from parameters

Helmholtz3dKernelReg

Kernel xlifepp::Helmholtz3dKernelReg(Parameters& = defaultParameters)

construct a Helmholtz3d kernel from parameters

Helmholtz3dKernelSing

Kernel xlifepp::Helmholtz3dKernelSing(Parameters& = defaultParameters)

construct a Helmholtz3d kernel from parameters

Helmholtz3dNxdotGradx

complex_t xlifepp::Helmholtz3dNxdotGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)

nx.gradx

Helmholtz3dNydotGrady

complex_t xlifepp::Helmholtz3dNydotGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)

ny.grady

Helmholtz3dNydotGradyReg

complex_t xlifepp::Helmholtz3dNydotGradyReg(const Point &x, const Point &y, Parameters &pa)

Helmholtz3dReg

complex_t xlifepp::Helmholtz3dReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)

value

Helmholtz3dSing

complex_t xlifepp::Helmholtz3dSing(const Point &x, const Point &y, Parameters &pa = defaultParameters)

value

HelmholtzSingDLP0

template<class T>
T xlifepp::HelmholtzSingDLP0(T k, const Element *elt, const Point &pos)

HelmholtzSingDLP1

template<class T>
void xlifepp::HelmholtzSingDLP1(T k, const Element *elt, const Point &pos, Vector<T> &res)

hermitianInnerProductTpl

template<typename T1_iterator, typename T2_iterator>
complex_t xlifepp::hermitianInnerProductTpl(T1_iterator b1, T1_iterator e1, T2_iterator b2)

hermitian product

hermitianProduct

template<typename T, typename K>
T xlifepp::hermitianProduct(const std::vector<std::pair<number_t, T>> &u, const std::map<number_t, K> &v)

complex_t xlifepp::hermitianProduct(const SuTermVector&, const SuTermVector&)

hermitian product

complex_t xlifepp::hermitianProduct(const TermVector &tv1, const TermVector &tv2)

hermitian product

template<typename K1, typename K2>
complex_t xlifepp::hermitianProduct(const Vector<K1> &vecFirst, const Vector<K2> &vecSecond)

complex_t xlifepp::hermitianProduct(const VectorEntry&, const VectorEntry&)

hermitian product of two vectorentry’s

hexahedronQuadrature

Quadrature *xlifepp::hexahedronQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit hexahedron

homothetize

template<class Geom>
Geom xlifepp::homothetize(const Geom &g, const Parameter &p1)

apply a homothety on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::homothetize(const Geom &g, const Parameter &p1, const Parameter &p2)

apply a homothety on a Geom (2 keys) (template external)

template<class Geom>
Geom xlifepp::homothetize(const Geom &g, const Point &c = Point(0., 0., 0.), real_t factor = 0.)

apply a homothety on a Geom (template external)

template<class Geom>
Geom xlifepp::homothetize(const Geom &g, real_t factor)

apply a homothety on a Geom (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, const Parameter &p1)

apply a homothety on a Geometry (1 key) (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, const Parameter &p1, const Parameter &p2)

apply a homothety on a Geometry (2 keys) (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, const Point &c = Point(0., 0., 0.), real_t factor = 0.)

apply a homothety on a Geometry (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, real_t factor)

apply a homothety on a Geometry (template external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1)

apply a homothety on a Mesh (1 key)

apply a homothety on a Mesh (1 key) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a homothety on a Mesh (2 keys)

apply a homothety on a Mesh (2 keys) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a homothety on a Mesh (3 keys)

apply a homothety on a Mesh (3 keys) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

apply a homothety on a Mesh (4 keys)

apply a homothety on a Mesh (4 keys) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Point &c, real_t factor = 1.)

apply a homothety on a Mesh (external)

Mesh xlifepp::homothetize(const Mesh &m, real_t factor)

apply a homothety on a Mesh (external)

inline Point xlifepp::homothetize(const Point &g, const Parameter &p1)

apply a homothety on a Point (1 key) (template external)

inline Point xlifepp::homothetize(const Point &g, const Parameter &p1, const Parameter &p2)

apply a homothety on a Point (2 keys) (template external)

inline Point xlifepp::homothetize(const Point &g, const Point &c = Point(0., 0., 0.), real_t factor = 0.)

apply a homothety on a Point (template external)

inline Point xlifepp::homothetize(const Point &g, real_t factor)

apply a homothety on a Point (template external)

hornerAlgorithmTpl

template<typename scalar1, typename T1_iterator, typename scalar2>
scalar2 xlifepp::hornerAlgorithmTpl(scalar1 x, T1_iterator b, T1_iterator e, scalar2 p0)

if p0 == 0 this is Horner algorithm: a[n] + x * (a[n-1] + x * (a[n-2] +…+ x * (a[0])…)) else compute a[n] + x * (a[n-1] + x * (a[n-2] +…+ x * (a[0] + x * p0)…))

id

OperatorOnFunction &xlifepp::id(const Function&)

id(k)

OperatorOnKernel &xlifepp::id(const Kernel&)

id(k)

OperatorOnUnknown &xlifepp::id(const Unknown&)

“differential” operators applied to unknown

OperatorOnFunction &xlifepp::id(OperatorOnFunction&)

id(opf)

OperatorOnKernel &xlifepp::id(OperatorOnKernel&)

id(opk)

identityMatrix

template<typename T>
LargeMatrix<T> xlifepp::identityMatrix(const LargeMatrix<T> &mat)

iFactorize

void xlifepp::iFactorize(MatrixEntry&, MatrixEntry&, FactorizationType ft = _noFactorization)

factorize matrix as iLU (later or iLDLt or iLDL*)

void xlifepp::iFactorize(MatrixEntry &A, FactorizationType ift)

incomplete factorize matrix as ILU (or iLDLt or iLDL*), not preserving A

factorize matrix as iLU (later or iLDLt or iLDL*)

void xlifepp::iFactorize(TermMatrix &A, FactorizationType ft)

void xlifepp::iFactorize(TermMatrix &A, TermMatrix &Af, FactorizationType ft)

ifft

template<typename T>
std::vector<complex_t> xlifepp::ifft(const std::vector<T> &f)

template<typename T>
std::vector<complex_t> &xlifepp::ifft(const std::vector<T> &f, std::vector<complex_t> &g)

template<typename IterA, typename IterB>
void xlifepp::ifft(IterA ita, IterB itb, number_t log2n)

perform the inverse discrete Fourier transform of the discrete vector a of length n=2^log2n the result is the vector b of length 2^log2n bk = (1/n) sum_j=0,n-1 aj*exp(2*i*pi*j*k/n) ita: iterator at the beginning of a itb: iterator at the beginning of b log2n: log_2(n)

ildlstarFactorize

template<typename S>
void xlifepp::ildlstarFactorize(LargeMatrix<S> &mat)

ildltFactorize

template<typename S>
void xlifepp::ildltFactorize(LargeMatrix<S> &mat)

void xlifepp::ildltFactorize(TermMatrix &A, TermMatrix &Af)

illstarFactorize

template<typename S>
void xlifepp::illstarFactorize(LargeMatrix<S> &mat)

illtFactorize

template<typename S>
void xlifepp::illtFactorize(LargeMatrix<S> &mat)

illtluFactorize

void xlifepp::illtluFactorize(TermMatrix &A, TermMatrix &Af)

iluFactorize

template<typename S>
void xlifepp::iluFactorize(LargeMatrix<S> &mat)

void xlifepp::iluFactorize(TermMatrix &A, TermMatrix &Af)

imag

inline SymbolicFunction &xlifepp::imag(const SymbolicFunction &f)

TermMatrix xlifepp::imag(const TermMatrix &tm)

return imag part as a real TermMatrix

TermVector xlifepp::imag(const TermVector &tv)

extracts imag part

Vector<real_t> xlifepp::imag(const Vector<complex_t> &a)

imaginary part of a complex vector

Vector<real_t> xlifepp::imag(const Vector<real_t> &a)

real part of a complex vector

imaginary part of a real vector

Vector<Vector<real_t>> xlifepp::imag(const Vector<Vector<complex_t>> &a)

abs of a vector of complex vectors

imaginary part of a vector of complex vectors

Vector<Vector<real_t>> xlifepp::imag(const Vector<Vector<real_t>> &a)

abs of a vector of real vectors

imaginary part of a vector of real vectors

imagPart

inline real_t xlifepp::imagPart(const complex_t&)

Matrix<real_t> xlifepp::imagPart(const Matrix<complex_t> &cB)

imaginary part of a complex matrix

imag part of a complex matrix

Matrix<real_t> xlifepp::imagPart(const Matrix<real_t> &cB)

imag part of a real matrix

inline real_t xlifepp::imagPart(const real_t&)

inline SuTermVector xlifepp::imagPart(const SuTermVector &s)

imagTpl

template<typename T1_iterator, typename R_iterator>
void xlifepp::imagTpl(T1_iterator b1, T1_iterator e1, R_iterator Rb)

returns imaginary part of vector entries: R[i] = imag(T1[i])

inceol

inline void xlifepp::inceol(number_t n)

eol shortcut

increase blanks

incompleteFunction

void xlifepp::incompleteFunction(const string_t &s = "")

message sent when function not fully defined

info

template<typename T>
void xlifepp::info(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
void xlifepp::info(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void xlifepp::info(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5>
void xlifepp::info(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4>
void xlifepp::info(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3>
void xlifepp::info(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2>
void xlifepp::info(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)

void xlifepp::info(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)

shortcut of msg for info type messages

throw info messages

init

void xlifepp::init()

initializes execution of XLiFE++

void xlifepp::init(const Parameter &p1)

void xlifepp::init(const Parameter &p1, const Parameter &p2)

void xlifepp::init(const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::init(const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

void xlifepp::init(const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

void xlifepp::init(const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

void xlifepp::init(const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

void xlifepp::init(const std::vector<Parameter> &ps, int argc, char **argv)

void xlifepp::init(int argc, char **argv)

void xlifepp::init(int argc, char **argv, const Parameter &p1)

void xlifepp::init(int argc, char **argv, const Parameter &p1, const Parameter &p2)

void xlifepp::init(int argc, char **argv, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::init(int argc, char **argv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

void xlifepp::init(int argc, char **argv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

void xlifepp::init(int argc, char **argv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

void xlifepp::init(int argc, char **argv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

initBuild

void xlifepp::initBuild(Language lang, number_t verboseLevel, int_t nbThreads, bool trackingMode, bool pushpop, bool traceMemory, bool isLogged, const std::vector<string_t> &syskeys, const std::vector<string_t> &authorizedExtensions)

initialize execution of XLiFE++

initCylinderSidePartGeodesic

void xlifepp::initCylinderSidePartGeodesic(Parameters &params)

initGmshMap

void xlifepp::initGmshMap(GMSHMAP &gmMap)

initHelmholtz2dHalfPlaneKernel

void xlifepp::initHelmholtz2dHalfPlaneKernel(Kernel&, Parameters&)

initialize kernel data

initHelmholtz2dKernel

void xlifepp::initHelmholtz2dKernel(Kernel&, Parameters&)

initialize kernel data

initHelmholtz2dStripKernel

void xlifepp::initHelmholtz2dStripKernel(Kernel&, Parameters&)

initialize kernel data

initHelmholtz3dKernel

void xlifepp::initHelmholtz3dKernel(Kernel&, Parameters&)

initialize kernel data

initMaxwell3dKernel

void xlifepp::initMaxwell3dKernel(Kernel&, Parameters&)

initialize kernel data

initNavier3dKernel

void xlifepp::initNavier3dKernel(Kernel&, Parameters&)

initialize kernel data

initRandomGenerators

void xlifepp::initRandomGenerators(int)

initialize random generators from a seed

innerProduct

complex_t xlifepp::innerProduct(const SuTermVector&, const SuTermVector&)

inner product

complex_t xlifepp::innerProduct(const TermVector &tv1, const TermVector &tv2)

inner product

complex_t xlifepp::innerProduct(const VectorEntry&, const VectorEntry&)

inner product of two vectorentry’s

integer

int_t xlifepp::integer(const Parameter&)

cast to int

integral

template<typename K>
PolynomialT<K> xlifepp::integral(VariableName vn, const MonomialT<K> &m)

template<typename K>
PolynomialT<K> xlifepp::integral(VariableName vn, const PolynomialT<K> &p)

template<typename K>
std::vector<PolynomialT<K>> xlifepp::integral(VariableName vn, const std::vector<PolynomialT<K>> &ps)

integralRepresentation

TermMatrix xlifepp::integralRepresentation(const GeomDomain&, const LinearForm&, string_t nam = "IR")

integral representation, no unknown

template<typename T>
Vector<T> &xlifepp::integralRepresentation(const GeomDomain &dom, const LinearForm &lf, const TermVector &U, Vector<T> &val, std::vector<Point> &xs)

points are given from a GeomDomain, return values and points in input arguments list (pts)

template<typename T>
Vector<T> &xlifepp::integralRepresentation(const GeomDomain &dom, const std::pair<LinearForm, const TermVector*> lftv, Vector<T> &val, std::vector<Point> &pts)

TermMatrix xlifepp::integralRepresentation(const std::vector<Point>&, const LinearForm&, string_t nam = "IR")

integral representation, no unknown, no domain

template<typename T>
Vector<T> &xlifepp::integralRepresentation(const std::vector<Point> &xs, const LinearForm &lf, const TermVector &U, Vector<T> &val, const std::vector<Vector<real_t>> &ns = std::vector<Vector<real_t>>())

compute integral representation on a set of points: intg_gamma op(K)(xi,y) aop op(u) dy op(K) : operator on a Kernel K op(u) : operator on a TermVector u (defined on gamma) aop: algebraic operator

syntax examples: Vector<real_t> val; integralRepresentation(Points, intg(gamma,G * u), U, val); //U values of unknown integralRepresentation(Points, intg(gamma,(grad_y(G)|_ny) * u, U, GaussLegendre,3), val); integralRepresentation(Points, intg(gamma,(grad_x(G)|_nx) * u, U, GaussLegendre,3), val);

be cautious, returned values may be of type Vector<real_t>, Vector<complex_t> and has to be consistent with computation

template<typename T>
Vector<Vector<T>> &xlifepp::integralRepresentation(const std::vector<Point> &xs, const LinearForm &lf, const TermVector &U, Vector<Vector<T>> &val, const std::vector<Vector<real_t>> &ns = std::vector<Vector<real_t>>())

compute integral representation on a set of points returning a vector of vector

template<typename T>
Vector<T> &xlifepp::integralRepresentation(const std::vector<Point> &xs, const std::pair<LinearForm, const TermVector*> lftv, Vector<T> &val, const std::vector<Vector<real_t>> &ns = std::vector<Vector<real_t>>())

compute int_dom opker(x,y) * tv(y) on points, return values and points in input arguments list (pts)

TermVector xlifepp::integralRepresentation(const Unknown&, const GeomDomain&, const LinearForm&, const TermVector&, const string_t &nam = "IR")

integralRepresentation, points are given from a GeomDomain, return a TermVector related to unknown u

TermMatrix xlifepp::integralRepresentation(const Unknown&, const GeomDomain&, const LinearForm&, string_t nam = "IR")

integral representation

inline TermVector xlifepp::integralRepresentation(const Unknown &u, const GeomDomain &dom, std::pair<LinearForm, const TermVector*> lftv, const string_t &nam = "IR")

compute int_dom opker(x,y) * tv(y) on a domain, return a TermVector related to unknown u

integrandLapDLP0

real_t xlifepp::integrandLapDLP0(const Point &Sm, const Point &Sp, real_t h, real_t d, const Point &Ip)

integrandLapDLP1const

real_t xlifepp::integrandLapDLP1const(const Point &Sm, const Point &Sp, real_t h, real_t d, const Point &Ip)

integrandLapDLP1lin

void xlifepp::integrandLapDLP1lin(const Point &Sm, const Point &Sp, real_t h, real_t d, const Point &Ip, Vector<real_t> &res)

integrandLapSLP0

real_t xlifepp::integrandLapSLP0(const Point &Sm, const Point &Sp, real_t h, real_t d, const Point &Ip, real_t alpha = 1.)

Explicit primitives

integrandLapSLP1const

real_t xlifepp::integrandLapSLP1const(const Point &Sm, const Point &Sp, real_t h, real_t d, const Point &Ip, real_t alpha = 1.)

integrandLapSLP1lin

void xlifepp::integrandLapSLP1lin(const Point &Sm, const Point &Sp, real_t h, real_t d, const Point &Ip, Vector<real_t> &res, real_t alpha = 1.)

internalSides

GeomDomain &xlifepp::internalSides(GeomDomain &dom)

access to domain defined from all internal sides of elements of domain dom, create it if not defined

interpolate

TermVector xlifepp::interpolate(const Unknown&, const GeomDomain&, const TermVector&, const string_t &na = "")

interpolation of a TermVector on a domain, specifying unknown

interpolatedNormals

void xlifepp::interpolatedNormals(Space &sp, std::vector<Vector<real_t>> &ns)

compute interpolated normals on Lagrange Dofs of space sp solve the projection problem Mk*nk = M0*n0 where Mk is the mass matrix associated to sp interpolation M0 is the “hybrid” mass matrix between sp interpolation and P0 interpolation the normals are returned as a vector of Vector

compute interpolated normals on Lagrange Dofs of space sp

NOTE: this method is well adapted for planar element (same normal every where in element) in case of curved geometric element, the method may be improved by using Gauss Lobatto interpolation of higher degree

interpolation

Interpolation &xlifepp::interpolation(FEType typ, FESubType sub, number_t num, SobolevType spa)

main “constructor” by finding first if already exists

interpolent

TermVector xlifepp::interpolent(const Unknown &u, const GeomDomain &dom, const Function &f, const Function &gradf, const Function &grad2f)

evaluate dofs on a function: dof_i(f) for any dofs related to unknown u and domain

intersect

bool xlifepp::intersect(const GeomElement &E1, const GeomElement &E2, real_t tol)

intersectionHalfLineEllipse

Point xlifepp::intersectionHalfLineEllipse(const Point &M, const std::vector<real_t> &d, const Point &C, const Point &A, const Point &B, bool &hasUniqueIntersection, real_t tmin, real_t tmax, real_t tol)

intersection half line (M,D) with ellipse (C,A,B, tmin, tmax) C center, A first apogee, B second apogee, sector [tmin,tmax], tmin,tmax in [0,2pi] P(t)= C + CA*cos(t) + CB*sin(t) t in (tmin,tmax) P1=P(tmin), P2=P(tmax) return void Point if no intersection or on boundary assume 3D points, A!=B, D!=0 and DxAB!=0 (non paralell)

intersection half line (M,d) with ellipse (C,A,B,tmin,tmax)

intersectionHalfLinePolygon

Point xlifepp::intersectionHalfLinePolygon(const Point &M, const std::vector<real_t> &d, const std::vector<Point> &vs, bool &hasUniqueIntersection, real_t tol)

intersection half line (M,D) with polygon given by its vertices

intersection half line (M,d) with polygon vs=(v1,v2,…vn)

intersectionHalfLineSegment

Point xlifepp::intersectionHalfLineSegment(const Point &M, const std::vector<real_t> &d, const Point &A, const Point &B, bool &hasUniqueIntersection, real_t tol)

intersection of half line [M,d) with segment [AB] return void Point if no intersection or non unique point assume 3D points, A!=B, d!=0

intersection half line (M,d) with segment [AB]

intersectionOfPlanes

std::pair<Point, Point> xlifepp::intersectionOfPlanes(const Point &S1, const Point &S2, const Point &S3, const Point &T1, const Point &T2, const Point &T3)

straight line intersection I of 2 planes (S1,S2,S3) and (T1,T2,T3) returns a pair of points defining the intersection

straight line intersection of 2 planes defined respectively by 3 non aligned points

intersectionOfPlanesWithOneSharedPoint

Point xlifepp::intersectionOfPlanesWithOneSharedPoint(const Point &S1, const Point &S2, const Point &S3, const Point &T2, const Point &T3)

straight line intersection of 2 planes (S1,S2,S3) and (S1,T2,T3) S1 is on the intersection, so the remaining calculations are shorter returns a point defining the intersection with S1

straight line intersection of 2 planes defined respectively by 3 non aligned points with one vertex in common

intersectionOfSegments

bool xlifepp::intersectionOfSegments(const Point &A, const Point &B, const Point &C, const Point &D, Point &I, real_t tol)

unique intersection of segments [AB] and [CD], in 2D-3D all points have the same dimension, return true if intersection exists and is unique, else false (CDAB non coplanar or CD//AB) I= (1-alpha)*C + alpha*D = (1-gamma)*A + gamma*B and nCD: normal to CD in CDAB plane gamma = AC.nCD / PQ.nCD alpha = (AP+gamma*AB.CD)/CD.CD alpha and gamma must belong to [0,1] with a tolerance t, say [-t, 1+t]

intersectionOfStraightLines

Point xlifepp::intersectionOfStraightLines(const Point &S1, const Point &S2, const Point &T1, const Point &T2, bool &hasIntersect)

intersection point I of straight lines (S1S2) and (T1T2) if (S1S2) // (T1T2), I is of size 0 and hasIntersect is set to false else hasIntersect is set to true

intersection of straight lines

intersectionSegmentQuadrangle

bool xlifepp::intersectionSegmentQuadrangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, const Point &D, Point &I, Point &J, real_t tol)

intersectionSegmentTriangle

bool xlifepp::intersectionSegmentTriangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, Point &I, Point &J, real_t tol)

strict intersection of [P,Q] and triangle [A,B,C] all points must have the same dimension (not checked) return true if some intersection points exist else false in 3D non coplanar case: return one or no point in 3D coplanar or 2D cases: return one or two or no point in other words, if intersection is a segment [I,J] (I!=J) it returns false ans I,J are not updated

intg

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv)

User single intg routines involving Kernel and TermVector (with up to 5 keys)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const IntegrationMethod &im)

Deprecated:

use key-value system for optional arguments (_quad, _order, _method, …)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const IntegrationMethods &ims)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const Parameter &p1)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const Parameter &p1, const Parameter &p2)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const Parameter &p1, const Parameter &p2, const Parameter &p3)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, const std::vector<Parameter> &ps)

main routine for single integrals involving Kernel and TermVector

std::pair<LinearForm, const TermVector*> xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnTermVector &koptv, QuadRule qr, number_t qro)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus)

Basic single intg routines with kernels for users (with up to 10 keys)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

LinearForm xlifepp::intg(const GeomDomain &dom, const KernelOperatorOnUnknowns &kopus, QuadRule qr, number_t qo, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu)

Advanced (linear combinations) single intg routines for users (with up to 10 keys)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &Lcopu, ComputationType ct, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &Lcopu, ComputationType ct, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &Lcopu, ComputationType ct, QuadRule qr, number_t qo, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &Lcopu, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &Lcopu, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &lcopu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

LinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknown &Lcopu, QuadRule qr, number_t qo, bool isogeo)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus)

Advanced (linear combinations) single intg routines for users (with up to 10 keys)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, bool isogeo, QuadRule qr, number_t qo = 0, SymType st = _undefSymmetry)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, QuadRule qr, number_t qo, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const LcOperatorOnUnknowns &lcopus, SymType st)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu)

Basic single intg routines for users (with up to 10 keys)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, bool isogeo, QuadRule qr, number_t qo = 0, SymType st = _undefSymmetry)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, bool isogeo, SymType st = _undefSymmetry)

construct a simple intg bilinear form

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, const IntegrationMethod &im, SymType st)

Deprecated:

use key-value system for optional arguments (_quad, _order, _method, _symmetry, _isogeo, …)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, QuadRule qr, number_t qo, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, SymType st = _undefSymmetry)

construct a simple intg bilinear form

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, ComputationType ct, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, ComputationType ct, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, ComputationType ct, QuadRule qr, number_t qo, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, const std::vector<Parameter> &ps)

main routine for single integrals

LinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknown &opu, QuadRule qr, number_t qo, bool isogeo)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus)

Basic single intg routines for users (with up to 10 keys)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, bool isogeo, QuadRule qr, number_t qo = 0, SymType st = _undefSymmetry)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, const std::vector<Parameter> &ps)

main routine for single integrals

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, QuadRule qr, number_t qo, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &dom, const OperatorOnUnknowns &opus, SymType st)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, bool isogeo)

Deprecated:

use key-value system for optional arguments (_quad, _order, _method, _symmetry, _isogeo, …)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, ComputationType ct, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, ComputationType ct, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, ComputationType ct, QuadRule qr, number_t qo, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const IntegrationMethod &im, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const IntegrationMethods &ims, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

LinearForm xlifepp::intg(const GeomDomain &dom, const Unknown &u, QuadRule qr, number_t qo, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv)

User single intg routines involving Kernel and TermVector (with up to 5 keys)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const IntegrationMethod &im)

construct a simple intg linear form from KernelOperatorOnTermVector

Deprecated:

use key-value system for optional arguments (_quad, _order, _method, …)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, const std::vector<Parameter> &ps)

main routine for double integrals involving Kernel and TermVector

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnTermVectorAndUnknown &koptvv, QuadRule qr, number_t qo)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus)

Basic double intg routines with kernels for users.

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, bool isogeo, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const IntegrationMethods &ims, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const IntegrationMethods &ims, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, const std::vector<Parameter> &ps)

main routine to double integrals

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const KernelOperatorOnUnknowns &kopus, SymType st)

construct a double intg bilinear form from kernel operators combination

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus)

Advanced (linear combinations) double intg routines with kernels for users.

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, bool isogeo, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const IntegrationMethods &ims, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const IntegrationMethods &ims, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, const std::vector<Parameter> &ps)

main routine for advanced (linear combinations) intg routines with kernels

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const LcKernelOperatorOnUnknowns &lckopus, SymType st)

construct a double intg bilinear form from kernel operators combination and integration methods

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu)

Basic double intg routines for users (with up to 10 keys)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, bool isogeo, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, const IntegrationMethods &ims, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, const IntegrationMethods &ims, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aop, const OperatorOnUnknown &opv, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, bool isogeo, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethods &ims, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethods &ims, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const Kernel &ker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, bool isogeo, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethods &ims, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, const IntegrationMethods &ims, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, AlgebraicOperator aopu, const OperatorOnKernel &opker, AlgebraicOperator aopv, const OperatorOnUnknown &opv, SymType st)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const IntegrationMethod &im, bool isogeo = false)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknown &opu, const std::vector<Parameter> &ps)

main routine for double integrals

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus)

Basic double intg routines without kernels, for users.

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, bool isogeo, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const IntegrationMethod &im, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const IntegrationMethod &im, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const IntegrationMethods &ims, bool isogeo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const IntegrationMethods &ims, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, QuadRule qr, number_t qo, SymType st)

BilinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const OperatorOnUnknowns &opus, SymType st)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const IntegrationMethod &im, bool isogeo = false)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9)

LinearForm xlifepp::intg(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7, const Parameter &p8, const Parameter &p9, const Parameter &p10)

LinearForm xlifepp::intg(const GeomDomain &domx, const GeomDomain &domy, const OperatorOnUnknown &opu, QuadRule qr, number_t qo, bool isogeo)

LinearForm xlifepp::intg(const GeomDomain &domx, const GeomDomain &domy, const Unknown &u, QuadRule qr, number_t qo, bool isogeo)

intgBFBuildParam

void xlifepp::intgBFBuildParam(const Parameter &p, real_t &bound, bool &isogeom, IntegrationMethod *&meth, IntegrationMethods &meths, QuadRule &qr1, number_t &qo1, QuadRule &qr2, number_t &qo2, SymType &st, StorageBuildType &sbtype, const GeomDomain *&extdomu, const GeomDomain *&extdomv)

get values of keys used in intg routines

intgBFParamCompatibility

void xlifepp::intgBFParamCompatibility(const ParameterKey &key, std::set<ParameterKey> &usedParams)

check compatibility between keys used in intg routines

intgLfBuildParam

void xlifepp::intgLfBuildParam(const Parameter &p, real_t &bound, bool &isogeom, IntegrationMethod *&meth, IntegrationMethods &meths, QuadRule &qr, number_t &qo, SymType &st, ComputationType &ct, const GeomDomain *&extdom)

get values of keys used in intg routines

intgLfParamCompatibility

void xlifepp::intgLfParamCompatibility(const ParameterKey &key, std::set<ParameterKey> &usedParams)

check compatibility between keys used in intg routines

intToDim

inline dimen_t xlifepp::intToDim(int_t i, const string_t &loc = "?")

intToNum

inline number_t xlifepp::intToNum(int_t i, const string_t &loc = "?")

inv

SymbolicTermMatrix &xlifepp::inv(const TermMatrix &M)

SymbolicTermMatrix &xlifepp::inv(SymbolicTermMatrix &S)

invalidFunction

void xlifepp::invalidFunction(const string_t &s = "")

message sent when function not valid

invCylinderSidePartGeodesic

Vector<real_t> xlifepp::invCylinderSidePartGeodesic(const Point &pt, Parameters &params, DiffOpType d)

inverse

inline complex_t xlifepp::inverse(const complex_t &z)

template<typename K>
Matrix<K> xlifepp::inverse(const Matrix<K> &m)

inline real_t xlifepp::inverse(const real_t &r)

TermMatrix xlifepp::inverse(TermMatrix &A)

inverse1DSpline

static Vector<real_t> xlifepp::inverse1DSpline(const Spline &sp, const Point &pt, const string_t &name)

inverse of the parametrization of a 1D spline: parameter t in [0,1] of the point pt of the curve (closest point) error if pt is not on the curve (an inverse that always fails disabled the generic Newton method of Parametrization::toParameter)

invParametrization_BezierSpline

inline Vector<real_t> xlifepp::invParametrization_BezierSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_BSpline

inline Vector<real_t> xlifepp::invParametrization_BSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_C2Spline

inline Vector<real_t> xlifepp::invParametrization_C2Spline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_CatmullRomSpline

inline Vector<real_t> xlifepp::invParametrization_CatmullRomSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_CircArc

inline Vector<real_t> xlifepp::invParametrization_CircArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_EllArc

inline Vector<real_t> xlifepp::invParametrization_EllArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Ellipse

inline Vector<real_t> xlifepp::invParametrization_Ellipse(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_EllipsoidSidePart

inline Vector<real_t> xlifepp::invParametrization_EllipsoidSidePart(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Nurbs

inline Vector<real_t> xlifepp::invParametrization_Nurbs(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Parallelogram

inline Vector<real_t> xlifepp::invParametrization_Parallelogram(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_ParametrizedArc

inline Vector<real_t> xlifepp::invParametrization_ParametrizedArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Piecewise

inline Vector<real_t> xlifepp::invParametrization_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Quadrangle

inline Vector<real_t> xlifepp::invParametrization_Quadrangle(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Segment

inline Vector<real_t> xlifepp::invParametrization_Segment(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_SplineArc

inline Vector<real_t> xlifepp::invParametrization_SplineArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_SplineSurface

inline Vector<real_t> xlifepp::invParametrization_SplineSurface(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

invParametrization_Triangle

inline Vector<real_t> xlifepp::invParametrization_Triangle(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call (Duffy)

invParametrization_TrunkSidePart

inline Vector<real_t> xlifepp::invParametrization_TrunkSidePart(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern invParametrization call

ioElementsByNoSplitting

vector<pair<ShapeType, vector<number_t>>> xlifepp::ioElementsByNoSplitting(const Space *sp, map<number_t, number_t> renumbering)

construct list of node numbers for each element return the list of pair of shape element and node number

ioElementsByRenumbering

Vector<number_t> xlifepp::ioElementsByRenumbering(ShapeType st, number_t N, const Vector<number_t>&)

ioElementsBySplitting

vector<pair<ShapeType, vector<number_t>>> xlifepp::ioElementsBySplitting(const Space *sp, map<number_t, number_t> renumbering)

construct list of node numbers for each element after splitting space elements return the list of pair of shape O1 element and node number

ioPoints

pair<vector<Point>, map<number_t, number_t>> xlifepp::ioPoints(const Space *sp)

extract coordinates of output order 1 split mesh from dofs return as a pair, the list of O1 nodes and the renumbering map dofid -> i (rank of O1 node)

is32bits

inline bool xlifepp::is32bits()

is64bits

inline bool xlifepp::is64bits()

isComment

bool xlifepp::isComment(const string_t &line)

check if the current line is not a comment

isDualSaddlePoint

bool xlifepp::isDualSaddlePoint(const TermMatrix &A)

factorize matrix as LU or LDLt or LDL* along matrix property move to global scalar representation in any case

if ft=_noFactorisation, type of factorization is searched if matrix is symmetric ldlt factorisation is used if matrix is self-adjoint ldlstar factorisation is used note that factorisation may be failed because there is no pivoting strategy (except for definite symmetric matrix!) if matrix is skew-adjoint ldlstar factorisation may be worked if the diagonal is non zero if matrix is skew-symmetric (diagonal is zero!) ldlt failed in any case ! For the moment LU factorisation is used in case of a skew-adjoint or a skew-symmetric matrix in future, for specific algorithm for skew symmetric or skew adjoint matrices see following papers: Bunch J.R. Stable Algorithms for Solving Symmetric and Skew-Symmetric Systems, Bull. Austral. Math. Soc., vol 26, 107-119, 1982 Lau T., Numerical Solution of Skew-Symmetric Linear Systems, Master Thesis, University of British Columbia, 2007

If umfPack is available, it is used when ft is not specified if withPermution = true, LU with row permutation will be used to deal with dense matrices

true if A is the saddle point matrix produced by the dual reduction of essential conditions (Lagrange multipliers): | A C* | | C 0 | symmetric (if A is) but indefinite with a zero diagonal block, so that factorizations without pivoting (LDLt, LDL*, LLt, LL*, and their incomplete versions) and CG are not suited

isequal

bool xlifepp::isequal(const SymbolicFunction&, const SymbolicFunction&)

check equality of two symbolic functions

isNameAvailable

bool xlifepp::isNameAvailable(const string_t &keyname)

check if a name is not a system key name

isPathExist

bool xlifepp::isPathExist(const string_t &path)

check if path exists

isPointInQuadrangle

inline bool xlifepp::isPointInQuadrangle(const Point &P, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol = theEpsilon)

test if a point P is inside a quadrangle ABCD

isPointInSegment

bool xlifepp::isPointInSegment(const Point &P, const Point &A, const Point &B, real_t tol)

test if P belongs to [A,B], works in 2D-3D, assuming same point dimensions

test if a point P is inside a segment [AB]

isPointInTriangle

bool xlifepp::isPointInTriangle(const Point &P, const Point &A, const Point &B, const Point &C, real_t tol = theEpsilon)

test if a point P is inside a triangle ABC

isRealReduced

bool xlifepp::isRealReduced(const TermMatrix &A)

isSegmentInQuadrangle

inline bool xlifepp::isSegmentInQuadrangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol = theEpsilon)

test if a segment [PQ] is inside a quadrangle ABCD

isSegmentInSegment

inline bool xlifepp::isSegmentInSegment(const Point &P, const Point &Q, const Point &A, const Point &B, real_t tol = theEpsilon)

test if a segment [PQ] is inside a segment [AB]

isSegmentInTriangle

inline bool xlifepp::isSegmentInTriangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, real_t tol = theEpsilon)

test if a segment [PQ] is inside a triangle ABC

isSingularIMType

bool xlifepp::isSingularIMType(IntegrationMethodType imt)

isTranslatedPoints

bool xlifepp::isTranslatedPoints(const std::vector<Point> &pts1, const std::vector<Point> &pts2, Point &T)

check if points pts1 are related by a translation to points pts2 if true update the translation vector T translation vector candidate is built from first construction point (may be not sufficient) any point of pts1 must be related by T to a point of pts2

check if points pts1 are related by a translation to points pts2 (T is the translation vector)

isTriangleInQuadrangle

inline bool xlifepp::isTriangleInQuadrangle(const Point &P, const Point &Q, const Point &R, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol = theEpsilon)

test if a triangle PQR is inside a quadrangle ABCD

isTriangleInTriangle

inline bool xlifepp::isTriangleInTriangle(const Point &P, const Point &Q, const Point &R, const Point &A, const Point &B, const Point &C, real_t tol = theEpsilon)

test if a triangle PQR is inside a triangle ABC

iterativeSolve

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1, const Parameter &p2)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1, const Parameter &p2, const Parameter &p3)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1, const Parameter &p2)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1, const Parameter &p2, const Parameter &p3)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1, const Parameter &p2)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, const std::vector<Parameter> &ps)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1, const Parameter &p2)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6)

TermVector xlifepp::iterativeSolve(TermMatrix &A, TermVector &B, Preconditioner &P, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5, const Parameter &p6, const Parameter &p7)

iterativeSolveGen

TermVector xlifepp::iterativeSolveGen(IterativeSolverType isType, TermMatrix &A, TermVector &B, const TermVector &X0, Preconditioner &P, real_t tol, number_t iterMax, const real_t omega, const number_t krylovDim, const number_t verboseLevel, const string_t &nam)

j_s

inline complex_t xlifepp::j_s(const complex_t &z, real_t x, const complex_t &q)

Parameters:

q – exp(-ixz) /(w2’(z)-qw2(z))

jacobiPolynomials

void xlifepp::jacobiPolynomials(real_t a, real_t b, real_t, std::vector<real_t>&)

Jacobi polynomials on [-1, 1] up to order n P_0 = 1, P_1 = (2*(a+1)+(a+b+2)*(x-1)) / 2 P_{n+1}*{ 2*(n+1)(n+a+b+1)(2*n+a+b) } = { (2*n+1+a+b)(a^2-b^2) + (2*n+a+b)(2*n+1+a+b)(2*n+2+a+b)*x } * P_{n} -{ 2*(n+a)*(n+b)(2*n+2+a+b) } * P_{n-1} , n > 0.

jacobiPolynomials01

void xlifepp::jacobiPolynomials01(real_t a, real_t b, real_t, std::vector<real_t>&)

Jacobi polynomials on [0, 1] up to order n.

jacobiPolynomialValue

static real_t xlifepp::jacobiPolynomialValue(number_t n, real_t a, real_t b, real_t x)

Jacobi polynomial P_n^(a,b)(x) by the three term recurrence (Abramowitz & Stegun 22.7.1)

join

inline string_t xlifepp::join(const Strings &ss, const string_t &delim)

join utility

jump

OperatorOnUnknown &xlifepp::jump(const Unknown &un)

OperatorOnUnknown &xlifepp::jump(OperatorOnUnknown &opu)

kroneckerProduct

template<typename K>
MatrixEigenDense<K> xlifepp::kroneckerProduct(MatrixEigenDense<K> &mat1, MatrixEigenDense<K> &mat2)

laguerre

template<typename T>
T xlifepp::laguerre(T (*f)(real_t), real_t t0, real_t a, number_t nq, std::vector<real_t> &quadpoints, std::vector<real_t> &quadweights)

template<typename T>
T xlifepp::laguerre(T (*f)(real_t, Parameters&), Parameters &pars, real_t t0, real_t a, number_t nq, std::vector<real_t> &quadpoints, std::vector<real_t> &quadweights)

LaguerreTable

void xlifepp::LaguerreTable(number_t n, std::vector<real_t> &quadpoints, std::vector<real_t> &quadweights)

lap

OperatorOnUnknown &xlifepp::lap(const Unknown &un)

lapG

OperatorOnUnknown &xlifepp::lapG(const Unknown &un, const complex_t &axx, const complex_t &ayy, const complex_t &azz)

Laplace2d

real_t xlifepp::Laplace2d(const Point &x, const Point &y, Parameters &pars)

value

Laplace2dGradx

Vector<real_t> xlifepp::Laplace2dGradx(const Point &x, const Point &y, Parameters &pars)

gradx

Laplace2dGradxy

Matrix<real_t> xlifepp::Laplace2dGradxy(const Point &x, const Point &y, Parameters &pa)

grad_x grad_y

Laplace2dGrady

Vector<real_t> xlifepp::Laplace2dGrady(const Point &x, const Point &y, Parameters &pars)

grady

Laplace2dKernel

Kernel xlifepp::Laplace2dKernel(Parameters &pars = defaultParameters)

construct a Laplace2d kernel

Laplace2dNxdotGradx

real_t xlifepp::Laplace2dNxdotGradx(const Point &x, const Point &y, Parameters &pars)

nx dot grad_x

Laplace2dNydotGrady

real_t xlifepp::Laplace2dNydotGrady(const Point &x, const Point &y, Parameters &pars)

ny dot grad_y

Laplace3d

real_t xlifepp::Laplace3d(const Point &x, const Point &y, Parameters &pars)

value

Laplace3dGradx

Vector<real_t> xlifepp::Laplace3dGradx(const Point &x, const Point &y, Parameters &pars)

gradx

Laplace3dGrady

Vector<real_t> xlifepp::Laplace3dGrady(const Point &x, const Point &y, Parameters &pars)

grady

Laplace3dKernel

Kernel xlifepp::Laplace3dKernel(Parameters &pars = defaultParameters)

construct a Laplace3d kernel

Laplace3dNxdotGradx

real_t xlifepp::Laplace3dNxdotGradx(const Point &x, const Point &y, Parameters &pars)

nx dot grad_x

Laplace3dNydotGrady

real_t xlifepp::Laplace3dNydotGrady(const Point &x, const Point &y, Parameters &pars)

ny dot grad_y

LaplaceDLP0

real_t xlifepp::LaplaceDLP0(const Element *elt, const Point &pos)

LaplaceDLP1

void xlifepp::LaplaceDLP1(const Element *elt, const Point &pos, Vector<real_t> &res)

LaplaceSLP0

real_t xlifepp::LaplaceSLP0(const Element *elt, const Point &pos)

LaplaceSLP1

void xlifepp::LaplaceSLP1(const Element *elt, const Point &pos, Vector<real_t> &res)

Computation functions

ldlstarFactorize

template<typename S>
void xlifepp::ldlstarFactorize(LargeMatrix<S> &mat)

void xlifepp::ldlstarFactorize(TermMatrix &A, TermMatrix &Af)

ldlstarLeftSolve

TermVectors xlifepp::ldlstarLeftSolve(TermMatrix &A, const std::vector<TermVector> &Bs, TermMatrix &Af)

TermVector xlifepp::ldlstarLeftSolve(TermMatrix &A, const TermVector &B, TermMatrix &Af)

ldlstarSolve

TermVectors xlifepp::ldlstarSolve(TermMatrix &A, const std::vector<TermVector> &Bs, TermMatrix &Af)

TermVector xlifepp::ldlstarSolve(TermMatrix &A, const TermVector &B, TermMatrix &Af)

ldltFactorize

template<typename S>
void xlifepp::ldltFactorize(LargeMatrix<S> &mat)

void xlifepp::ldltFactorize(TermMatrix &A, TermMatrix &Af)

factorization of a TermMatrix A in Af when the TermMatrix is stored as a compressed sparse matrix, it is restored as a skyline matrix when the TermMatrix is a multiple unknown matrix, the matrix is rewritten in a “single” unknown matrix stored as a skyline matrix or a dense matrix if all blocks are dense

ldltLeftSolve

TermVectors xlifepp::ldltLeftSolve(TermMatrix &A, const std::vector<TermVector> &Bs, TermMatrix &Af)

TermVector xlifepp::ldltLeftSolve(TermMatrix &A, const TermVector &B, TermMatrix &Af)

ldltSolve

TermVectors xlifepp::ldltSolve(TermMatrix &A, const std::vector<TermVector> &Bs, TermMatrix &Af)

TermVector xlifepp::ldltSolve(TermMatrix &A, const TermVector &B, TermMatrix &Af)

legendreFunctions

void xlifepp::legendreFunctions(real_t, std::vector<std::vector<real_t>> &Pml)

compute all Legendre functions up to order n for any real x: P^m_l(x) where n = Pml.size()-1 and l = 0,.., n and m = 0,..,n P^m_l(x) = (-1)^{m} * (1-x^2)^{m/2} d^m/dx^m[ P_l(x) ] where P_l is Legendre polynomial of degree l

legendreFunctionsDerivative

void xlifepp::legendreFunctionsDerivative(real_t, const std::vector<std::vector<real_t>>&, std::vector<std::vector<real_t>>&)

compute all Legendre functions derivatives up to order n for any real x: P’^m_l(x) from given Legendre functions up to order n for any real x: P^m_l(x) where n = Pml.size()-1 and l = 0,.., n and m = 0,..,n

legendreFunctionsDerivativeTest

void xlifepp::legendreFunctionsDerivativeTest(real_t x, number_t n, std::ostream &out)

LegendreFunctionsDerivativeTest

void xlifepp::LegendreFunctionsDerivativeTest(real_t, number_t, std::ostream&)

output function for test of Legendre Functions derivatives

legendreFunctionsTest

void xlifepp::legendreFunctionsTest(real_t x, number_t n, std::ostream&)

output function for test of Legendre Functions

legendrePolynomials

void xlifepp::legendrePolynomials(real_t, std::vector<real_t>&)

Legendre polynomials on [-1, 1] up to order n P_0(x) = 1, P_1(x) = x, n*P_n(x) = (2*n-1) x P_{n-1}(x) - (n-1) P_{n-2}(x) , n > 1.

legendrePolynomialsDerivative

void xlifepp::legendrePolynomialsDerivative(real_t, std::vector<real_t>&)

derivatives of Legendre polynomials on [-1, 1] up to order n: val[n] = P’n(x) P’_0(x) = 0, P’_1(x) = 1 P’_n(x) = n P{n-1}(x) + x P’_{n-1}(x) , n > 1

lineSpace

template<typename T>
Vector<T> xlifepp::lineSpace(const T &a, const T &b, number_t n)

linSpace

template<typename T>
std::vector<T> xlifepp::linSpace(const T &a, const T &b, number_t n)

return vector xi=a+i(b_a)/(n-1) i=0,n-1

linspace

template<typename T>
Vector<T> xlifepp::linspace(const T &a, const T &b, number_t n)

generates n points xi = a+i*dx with x = (b-a)/(n-1).

loadMeditElements

void xlifepp::loadMeditElements(std::istream &data, number_t spaceDim, ShapeType type, number_t dim, number_t nbVertices, std::vector<MELT> &melts, std::map<number_t, std::set<number_t>> &doms, std::map<ShapeType, ELTDEF> &elMap)

loadVizir4Elements

void xlifepp::loadVizir4Elements(std::istream &data, number_t spaceDim, ShapeType type, number_t dim, number_t nbVertices, std::vector<MELT2> &melts, std::map<number_t, std::set<number_t>> &doms, std::map<ShapeType, ELTDEF> &elMap)

locate

Geometry *xlifepp::locate(const Point &x, Point &dx, const std::map<number_t, Geometry*> &components, Geometry *last)

locateError

void xlifepp::locateError(bool warn, const string_t&, const GeomDomain&, const Point&, real_t d)

error management for locate tool

locateToleranceFactor

inline void xlifepp::locateToleranceFactor(real_t f)

log

inline SuTermVector xlifepp::log(const SuTermVector &s)

inline SymbolicFunction &xlifepp::log(const SymbolicFunction &f)

inline TermVector xlifepp::log(const TermVector &s)

template<typename K>
Vector<K> xlifepp::log(const Vector<K> &v)

log(v)

log10

inline SuTermVector xlifepp::log10(const SuTermVector &s)

inline SymbolicFunction &xlifepp::log10(const SymbolicFunction &f)

inline TermVector xlifepp::log10(const TermVector &s)

logGamma

complex_t xlifepp::logGamma(const complex_t&)

Paul Godfrey’s Lanczos implementation of the Gamma function.

real_t xlifepp::logGamma(real_t)

return Log(Gamma(x))

logGamma1

complex_t xlifepp::logGamma1(const complex_t&)

return Log(Gamma(z))

LogGamma1

complex_t xlifepp::LogGamma1(const complex_t &z)

logo

string_t xlifepp::logo(const dimen_t num)

logo returns random XLiFE++ logo (among 11!) as a multi-line string

logo returns ‘random’ XLiFE++ logo (among 11!) as a multi-line string

lookfor

bool xlifepp::lookfor(const string_t BeginSection, FILE *data)

bool xlifepp::lookfor(const string_t BeginSection, ifstream &data)

lowercase

string_t xlifepp::lowercase(const string_t &s)

convert “AbCdefg” to “abcdefg”

returns string_t converted to lowercase

lu

template<typename T>
Matrix<T> &xlifepp::lu(Matrix<T> &A)

template<typename T>
void xlifepp::lu(Matrix<T> &A, Matrix<T> &L, Matrix<T> &U)

template<typename T>
void xlifepp::lu(Matrix<T> &A, Matrix<T> &L, Matrix<T> &U, std::vector<dimen_t> &P)

template<typename T>
Matrix<T> &xlifepp::lu(Matrix<T> &A, Matrix<T> &LU)

LU factorization with no permutation, L lower triangular matrix with diagonal 1 stored in strict lower part of LU U upper triangular part stored in upper part of LU matrix LU may be the same as A.

template<typename T>
Matrix<T> &xlifepp::lu(Matrix<T> &A, Matrix<T> &LU, std::vector<dimen_t> &P)

LU factorization with real row permutation, PA = LU where P is a permutation matrix represented by a permutation vector p L lower triangular matrix with diagonal 1 stored in strict lower part of LU U upper triangular part stored in upper part of LU be care with operation on LU, permutation may have been applied for instance solving Ax=b should be done as LUx=Pb matrix LU may be the same as A.

template<typename T>
Matrix<T> &xlifepp::lu(Matrix<T> &A, std::vector<dimen_t> &P)

luFactorize

template<typename S>
void xlifepp::luFactorize(LargeMatrix<S> &mat, bool withPermutation = true)

void xlifepp::luFactorize(TermMatrix &A, TermMatrix &Af, bool withPermutation)

luLeftSolve

TermVectors xlifepp::luLeftSolve(TermMatrix &A, const std::vector<TermVector> &Bs, TermMatrix &Af)

TermVector xlifepp::luLeftSolve(TermMatrix &A, const TermVector &B, TermMatrix &Af)

luSolve

TermVectors xlifepp::luSolve(TermMatrix &A, const std::vector<TermVector> &Bs, TermMatrix &Af)

TermVector xlifepp::luSolve(TermMatrix &A, const TermVector &B, TermMatrix &Af)

makeParList

std::vector<Parameter> xlifepp::makeParList(int nbpar, ...)

mal_integrand

complex_t xlifepp::mal_integrand(real_t t, Parameters &pars)

integrand at (t,z), extern call, pars = (object, z)

mapNL

void xlifepp::mapNL(GeomMapData *mapP1, GeomMapData &gmap, Point &X, Point &x, real_t &eltdif, Vector<real_t> &n, bool withn)

mapShapeValues

inline void xlifepp::mapShapeValues(RefElement &refElt, MeshElement &melt, GeomMapData &mapdata, bool mapsh, FEMapType femt, bool rotsh, number_t ord, bool changeSign, const Vector<real_t> *sign, dimen_t dimfun, dimen_t &dimfunp, const ShapeValues &sh, ShapeValues &shmap)

mapTo

TermVector xlifepp::mapTo(const TermVector &v, const GeomDomain &dom, const Unknown &u, bool useNearest, bool errorOnOutDom, Function *fmap, real_t tol)

materialIdFromParameters

inline number_t xlifepp::materialIdFromParameters(Parameters &pars)

matmat

template<typename A_it, typename B_it, typename R_it>
void xlifepp::matmat(A_it it_ma, const dimen_t nbk, B_it it_mb, const dimen_t nbr, const dimen_t nbc, R_it it_mr)

matvec

template<typename K, typename V1_it, typename V2_it>
V2_it xlifepp::matvec(const Matrix<K> &m, const V1_it it_v1b, const V2_it it_v2b)

template<typename K, typename ITV, typename ITR>
void xlifepp::matvec(const SparseMatrix<K> &m, const ITV itv, const ITR itr)

template<typename M_it, typename V1_it, typename V2_it>
void xlifepp::matvec(M_it it_mb, const V1_it it_v1b, const V1_it it_v1e, V2_it it_v2b, V2_it it_v2e)

maxAbsVal

inline complex_t xlifepp::maxAbsVal(const complex_t&)

inline complex_t xlifepp::maxAbsVal(const real_t&)

template<typename K>
complex_t xlifepp::maxAbsVal(const Vector<K> &u)

return the value (in complex) of component being the largest one in absolute value

maxDegreeRule

void xlifepp::maxDegreeRule(int degree, const string_t &name, ShapeType sh, int maxdeg)

warning message

maxElementTpl

template<typename T_iterator>
T_iterator xlifepp::maxElementTpl(T_iterator b, T_iterator e)

returns iterator to first occurrence of maximum absolute magnitude in stl container

maxSeparator

int_t xlifepp::maxSeparator(const Point &p, const Point &q, int &c, real_t &s)

separation function used by KdTree

maxTpl

template<typename T, typename U>
T xlifepp::maxTpl(const T &a, const U &b)

returns maximum of 2 values

template<typename T, typename U, typename V>
T xlifepp::maxTpl(const T &a, const U &b, const V &c)

returns maximum of 3 values

Maxwell3d

Matrix<complex_t> xlifepp::Maxwell3d(const Point &x, const Point &y, Parameters &pa)

kernel computation: IG_t(k_s; x, y)=G(k_s; x, y)*I_3 + 1/k_s^2 * Hess(G(k_s; x, y)-G(k_p; x, y))

value

Maxwell3dCurlx

Matrix<complex_t> xlifepp::Maxwell3dCurlx(const Point &x, const Point &y, Parameters &pa)

kernel computation: Curlx(IG_t)

curlx

Maxwell3dCurlxy

Matrix<complex_t> xlifepp::Maxwell3dCurlxy(const Point &x, const Point &y, Parameters &pa)

kernel computation: CurlxCurly(IG_t)

curlx.curly

Maxwell3dCurly

Matrix<complex_t> xlifepp::Maxwell3dCurly(const Point &x, const Point &y, Parameters &pa)

kernel computation: Curly(IG_t)

curly

Maxwell3dDivx

Vector<complex_t> xlifepp::Maxwell3dDivx(const Point &x, const Point &y, Parameters &pa)

kernel computation: Divx(IG_t)

divx

Maxwell3dDivxy

complex_t xlifepp::Maxwell3dDivxy(const Point &x, const Point &y, Parameters &pa)

kernel computation: DivxDivy(IG_t)

divx.divy

Maxwell3dDivy

Vector<complex_t> xlifepp::Maxwell3dDivy(const Point &x, const Point &y, Parameters &pa)

kernel computation: Divy(IG_t)

divy

Maxwell3dKernel

Kernel xlifepp::Maxwell3dKernel(const complex_t &k, const real_t &t = 0)

construct a Maxwell3d kernel from complex k

Kernel xlifepp::Maxwell3dKernel(const real_t &k, const real_t &t = 0)

construct a Maxwell3d kernel from real k

Kernel xlifepp::Maxwell3dKernel(Parameters& = defaultParameters)

construct a Maxwell3d kernel from parameters

mean

OperatorOnUnknown &xlifepp::mean(const Unknown &un)

OperatorOnUnknown &xlifepp::mean(OperatorOnUnknown &opu)

measure

inline real_t xlifepp::measure(const GeomDomain &g)

measure (length, surface or volume) of Domain

merge

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 20 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 19 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 18 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 17 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 16 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 15 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 14 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 13 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 12 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 11 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 10 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 9 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 8 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 7 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 6 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 5 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 4 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)

merge 3 geometrical domains (true union of elements)

template<typename S_>
GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, S_ name)

merge 2 geometrical domains (true union of elements)

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, bool mergeSharedBoundary = true, const string_t &name = "#Omega")

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, const Mesh &m3, bool mergeSharedBoundary = true, const string_t &name = "#Omega")

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, const Mesh &m3, const Mesh &m4, bool mergeSharedBoundary = true, const string_t &name = "#Omega")

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, const Mesh &m3, const Mesh &m4, const Mesh &m5, bool mergeSharedBoundary = true, const string_t &name = "#Omega")

template<typename S_>
GeomDomain &xlifepp::merge(const std::vector<const GeomDomain*> &doms, S_ name)

merge some geometrical domains (true union of elements) GeomDomains must be MeshDomain of same dimension

merge some geometrical domains (true union of elements)

Mesh xlifepp::merge(const std::vector<const Mesh*> &ms, bool mergeSharedBoundary = true, const string_t &name = "#Omega")

merge meshes of same dimension

template<typename S_>
GeomDomain &xlifepp::merge(const std::vector<GeomDomain*> &doms, S_ name)

merge some geometrical domains (true union of elements) GeomDomains must be MeshDomain of same dimension

merge some geometrical domains (true union of elements), non const version

TermVector xlifepp::merge(const TermVector&, const TermVector&)

merge two termvectors, preserving values of first one when common dofs

mergeConstraints

std::map<const Unknown*, Constraints*> xlifepp::mergeConstraints(std::vector<Constraints*> &constraints)

merge constraints systems (if more than one conditions) it takes as input a vector of Constraints (each corresponding to an essential condition) and produces a map of Constraints indexed by unknown with two cases:

merge constraints

Case of uncoupled unknowns (u1/v1, u2/v2 referred to same unknown u/v), u and v are not coupled by constraints u1 u2 v1 v2 —————–&#8212; u1 u2 v1 v2 c1 |cu1 0 0 0 | | f1 ——-&#8212; ——&#8212; c2 | 0 cu2 0 0 | = | f2 ==> Cu = |cu1 0 | = fu= | f1 Cv = |cv1 cv2| = fv= | f3 c3 | 0 cv1 cv2 | | f3 | 0 cu2 | | f2 ——&#8212;

The merging process involving u1, u2 referring to same unknown u produces

Constraints object where common dofs are merged One Constraints object for each unknown is created and returned

Case of coupled unknowns (u1/v1, u2/v2 referred to same unknown u/v), u and v are coupled at least by one constraint u1 u2 v1 v2 —————-&#8212; u v c1 |cu1 0 0 0 | = | f1 ——&#8212; c2 | 0 cu2 cv1 cv2 | | f2 ==> |Cu Cv | = f

A global

Constraints matrix is created and returned (indexed by 0)

NOTE: when merging some Constraints in a new one the old ones are deleted by this function

mergeSubspaces

Space *xlifepp::mergeSubspaces(Space *&sp1, Space *&sp2, bool newSubspaces)

merge subspaces given by a list of Space pointer the union is allowed only for subspaces of same root space this function may return the root space, one of the subspaces or a new subspace if newSubspaces is true, new subspaces with union as parent are created and return as space pointers

merge two subspaces

Space *xlifepp::mergeSubspaces(std::vector<Space*> &sps, bool newSubspaces = false)

merge a list of subspaces

mergeSuTermMatrix

SuTermMatrix *xlifepp::mergeSuTermMatrix(const std::list<SuTermMatrix*>&)

merge SuTerMatrix’s referring to the same vector unknown

mergeSuTermVector

SuTermVector *xlifepp::mergeSuTermVector(const std::list<SuTermVector*>&)

merge blocks with components of the same unknown

message

template<typename T>
string_t xlifepp::message(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)

templated message functions (shortcuts avoiding the use of MsgData object)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, const T10 &v10, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2>
string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)

string_t xlifepp::message(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)

main function to throw an error/warning/info message where

build formated message

exemple: to throw the internal error with an int msgId and a string s paramaters data << s; msg(“msg_undef”, data, errInternal,_error);

NOTE that MsgData structure is cleared after call. data and errInternal,_error have default values theMessageData and theMessages_p

Parameters:

• msgIds – the string id of a message in this collection

• msgData – a data object containing the message parameters

• msgSrc – pointer to an error message formats collection

minElementTpl

template<typename T_iterator>
T_iterator xlifepp::minElementTpl(T_iterator b, T_iterator e)

returns iterator to first occurrence of minimum absolute magnitude in stl container

minTpl

template<typename T, typename U>
T xlifepp::minTpl(const T &a, const U &b)

returns minimum of 2 values

template<typename T, typename U, typename V>
T xlifepp::minTpl(const T &a, const U &b, const V &c)

returns minimum of 3 values

mixedProduct

real_t xlifepp::mixedProduct(const Point&, const Point&, const Point&)

returns the mixed product (AxB).C

msg

void xlifepp::msg(const string_t &msgIds, MsgData &msgData, Messages *msgSrc, MsgType &msgType)

throw messages

void xlifepp::msg(const string_t &msgIds, MsgData &msgData, Messages *msgSrc, MsgType msgType = _info)

general message handler

msgInit

void xlifepp::msgInit(const string_t &msgPath, std::ofstream &out)

initialization procedure for messages handling

initialization of engine for messages handling

mshAsciiExport

void xlifepp::mshAsciiExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

mshBinExport

void xlifepp::mshBinExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

mshExport

void xlifepp::mshExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

export a split mesh of a domain to msh format

mshType

number_t xlifepp::mshType(ShapeType sht, number_t order)

returns the id msh number of a shape, according to the finite elements order

mtlbExport

void xlifepp::mtlbExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

export a split mesh of a domain to Matlab - Octave format

void xlifepp::mtlbExport(const GeomDomain &dom, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, std::ostream &out)

multFactMatrixVector

template<typename T, typename V, typename R>
void xlifepp::multFactMatrixVector(const LargeMatrix<T> &mat, const std::vector<V> &vec, std::vector<R> &res)

product with factorized matrix no permutation: L*U*X or L*D*Lt*X or (L*D*L*)*X row permutation (PA=LU) : inv(P)*L*U*X or inv(P)*L*D*Lt*X or inv(P)*(L*D*L*)*X col permutation (AQ=LU) : L*U*inv(Q)*X or L*D*Lt*inv(Q)*X or (L*D*L*)*inv(Q)*X row and col permutation (PAQ=LU) : inv(P)*L*U*inv(Q)*X or inv(P)*L*D*Lt*inv(Q)*X or inv(P)*(L*D*L*)*inv(Q)*X called by multMatrixVector functions

multInverMatrixVector

template<typename S1, typename S2>
void xlifepp::multInverMatrixVector(const LargeMatrix<S1> &mat, std::vector<S2> &vec, std::vector<typename Conditional<NumTraits<S1>::IsComplex, S1, S2>::type> &res, FactorizationType fac)

multMatMat

template<typename K1, typename K2>
void xlifepp::multMatMat(const MatrixEigenDense<K1> &mat1, const MatrixEigenDense<K2> &mat2, MatrixEigenDense<typename Conditional<NumTraits<K1>::IsComplex, K1, K2>::type> &res)

multMatrix

template<typename T>
ApproximateMatrix<T> &xlifepp::multMatrix(ApproximateMatrix<T> &A, ApproximateMatrix<T> &B, ApproximateMatrix<T> &AB)

ApproximateMatrix * ApproximateMatrix -> ApproximateMatrix.

template<typename T>
ApproximateMatrix<T> &xlifepp::multMatrix(ApproximateMatrix<T> &A, LargeMatrix<T> &L, ApproximateMatrix<T> &AL)

ApproximateMatrix * LargeMatrix -> ApproximateMatrix.

template<typename T>
ApproximateMatrix<T> &xlifepp::multMatrix(LargeMatrix<T> &L, ApproximateMatrix<T> &A, ApproximateMatrix<T> &LA)

LargeMatrix * ApproximateMatrix -> ApproximateMatrix.

template<typename T>
LowRankMatrix<T> &xlifepp::multMatrix(LargeMatrix<T> &L, LowRankMatrix<T> &A, LowRankMatrix<T> &AL)

product of a LargeMatrix and a LowRankMatrix

template<typename T>
LowRankMatrix<T> &xlifepp::multMatrix(LowRankMatrix<T> &A, LargeMatrix<T> &L, LowRankMatrix<T> &AL)

product of a LowRankMatrix and a LargeMatrix

template<typename T>
LowRankMatrix<T> &xlifepp::multMatrix(LowRankMatrix<T> &A, LowRankMatrix<T> &B, LowRankMatrix<T> &AB)

product of two LowRankMatrix’s

multMatrixMatrix

template<typename SA, typename SB, typename SR>
void xlifepp::multMatrixMatrix(const LargeMatrix<SA> &mA, const LargeMatrix<SB> &mB, LargeMatrix<SR> &mR)

extern template product matrix*matrix the storage of the resulting matrix is ALWAYS dense there is no chance to get a sparse matrix except in case of product with a diagonal matrix where the storage is unchanged

template<typename SA, typename SB, typename SR>
void xlifepp::multMatrixMatrix(const LargeMatrix<SA> &mA, const std::vector<SB> &mB, LargeMatrix<SR> &mR)

template<typename SA, typename SB, typename SR>
void xlifepp::multMatrixMatrix(const std::vector<SA> &mA, const LargeMatrix<SB> &mB, LargeMatrix<SR> &mR)

multMatrixScalar

LargeMatrix<complex_t> xlifepp::multMatrixScalar(const LargeMatrix<complex_t> &mat, const real_t v)

Multiple a complex Matrix with real scalar The result matrix will point to the same storage.

Parameters:

• mat – complex matrix

• v – real scalar

Returns:

result matrix which share the same storage.

LargeMatrix<complex_t> xlifepp::multMatrixScalar(const LargeMatrix<real_t> &mat, const complex_t v)

Multiple a real Matrix with complex scalar The result matrix will point to the same storage.

Parameters:

• mat – real matrix

• v – complex scalar

Returns:

complex matrix which share the same storage.

template<typename T>
LargeMatrix<T> xlifepp::multMatrixScalar(const LargeMatrix<T> &mat, const T v)

Multiple a largeMatrix with a scalar The result matrix will point to the same storage.

Parameters:

• mat – matrix

• v – scalar

Returns:

result matrix which shares the same storage.

multMatrixVector

template<typename T, typename I>
Vector<T> xlifepp::multMatrixVector(const HMatrix<T, I> &h, const Vector<T> &x)

hmatrix vector product

void xlifepp::multMatrixVector(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec, std::vector<complex_t> &res)

void xlifepp::multMatrixVector(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec, std::vector<Vector<complex_t>> &res)

void xlifepp::multMatrixVector(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec, std::vector<Vector<complex_t>> &res)

template<typename T>
void xlifepp::multMatrixVector(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec, std::vector<Vector<T>> &res)

templated mat<Matrix<T> > * vec<Vector<T> >

void xlifepp::multMatrixVector(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec, std::vector<complex_t> &res)

template<typename T>
void xlifepp::multMatrixVector(const LargeMatrix<T> &mat, const std::vector<T> &vec, std::vector<T> &res)

templated mat<T> * vec<T>

template<typename T, typename V, typename R>
void xlifepp::multMatrixVector(const LargeMatrix<T> &mat, V *vp, R *rp)

templated mat<T> * vec<V> (pointer form)

template<typename K>
void xlifepp::multMatrixVector(const Matrix<K> &m, const Vector<K> &v, Vector<K> &mv)

void xlifepp::multMatrixVector(const MatrixEntry&, const VectorEntry&, VectorEntry&)

matrix * vector

TermVector xlifepp::multMatrixVector(const SymbolicTermMatrix &S, const TermVector &X)

TermVector &xlifepp::multMatrixVector(const TermMatrix&, const TermVector&, TermVector&)

product TermMatrix * TermVector

multMatVecLargeMatrixAdapter

template<typename Scalar, typename ScalarTypeX, typename MatrixType>
void xlifepp::multMatVecLargeMatrixAdapter(const LargeMatrixAdapter<MatrixType, Scalar> &m, const MultiVec<ScalarTypeX> &x, MultiVec<typename Conditional<NumTraits<Scalar>::IsComplex, Scalar, ScalarTypeX>::type> &y)

multScalarThenAssign

template<typename T>
void xlifepp::multScalarThenAssign(TermVector &tv, const T &t)

operation U*=t

p*=t

template<typename K, typename KK>
void xlifepp::multScalarThenAssign(Vector<K> &v, const KK &x)

void xlifepp::multScalarThenAssign(Vector<real_t> &v, const complex_t &c)

multVectorFactMatrix

template<typename T, typename V, typename R>
void xlifepp::multVectorFactMatrix(const LargeMatrix<T> &mat, const std::vector<V> &vec, std::vector<R> &res)

product with factorized matrix A=LU, or A=LDLt or A =LDL* no permutation: X*L*U = (Ut*Lt*Xt)t row permutation (PA=LU) : X*inv(P)*L*U = Ut*Lt*inv(P)t*Xt = Ut*Lt*P*Xt col permutation (AQ=LU) : X*L*U*inv(Q) = inv(Q)t*Ut*Lt*Xt = Q*Ut*Lt*Xt row and col permutation (PAQ=LU) : X*inv(P)*L*U*inv(Q) = inv(Q)t*Ut*Lt*inv(P)t*Xt = Q*Ut*Lt*P*Xt called by multMatrixVector

multVectorMatrix

void xlifepp::multVectorMatrix(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec, std::vector<complex_t> &res)

void xlifepp::multVectorMatrix(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec, std::vector<Vector<complex_t>> &res)

void xlifepp::multVectorMatrix(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec, std::vector<Vector<complex_t>> &res)

template<typename T>
void xlifepp::multVectorMatrix(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec, std::vector<Vector<T>> &res)

void xlifepp::multVectorMatrix(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec, std::vector<complex_t> &res)

template<typename T>
void xlifepp::multVectorMatrix(const LargeMatrix<T> &mat, const std::vector<T> &vec, std::vector<T> &res)

template<typename T, typename V, typename R>
void xlifepp::multVectorMatrix(const LargeMatrix<T> &mat, V *vp, R *rp)

templated vec<V> * mat<T> (pointer form)

void xlifepp::multVectorMatrix(const MatrixEntry&, const VectorEntry&, VectorEntry&)

vector * matrix

void xlifepp::multVectorMatrix(const std::vector<complex_t> &vec, const LargeMatrix<real_t> &mat, std::vector<complex_t> &res)

void xlifepp::multVectorMatrix(const std::vector<real_t> &vec, const LargeMatrix<complex_t> &mat, std::vector<complex_t> &res)

template<typename T>
void xlifepp::multVectorMatrix(const std::vector<T> &vec, const LargeMatrix<T> &mat, std::vector<T> &res)

void xlifepp::multVectorMatrix(const std::vector<Vector<complex_t>> &vec, const LargeMatrix<Matrix<real_t>> &mat, std::vector<Vector<complex_t>> &res)

void xlifepp::multVectorMatrix(const std::vector<Vector<real_t>> &vec, const LargeMatrix<Matrix<complex_t>> &mat, std::vector<Vector<complex_t>> &res)

template<typename T>
void xlifepp::multVectorMatrix(const std::vector<Vector<T>> &vec, const LargeMatrix<Matrix<T>> &mat, std::vector<Vector<T>> &res)

TermVector &xlifepp::multVectorMatrix(const TermMatrix&, const TermVector&, TermVector&)

product TermVector * TermMatrix

TermVector &xlifepp::multVectorMatrix(const TermVector&, const TermMatrix&, TermVector&)

product TermVector * TermMatrix

TermVector xlifepp::multVectorMatrix(const TermVector &X, const SymbolicTermMatrix &S)

template<typename K>
void xlifepp::multVectorMatrix(const Vector<K> &v, const Matrix<K> &m, Vector<K> &mv)

void xlifepp::multVectorMatrix(const VectorEntry&, const MatrixEntry&, VectorEntry&)

vector * matrix

template<typename T, typename V, typename R>
void xlifepp::multVectorMatrix(V *vp, const LargeMatrix<T> &mat, R *rp)

templated vec<V> * mat<T> (pointer form)

nabla

OperatorOnUnknown &xlifepp::nabla(const Unknown &un)

nabla_x

OperatorOnKernel &xlifepp::nabla_x(const Kernel&)

grad_x(k)

OperatorOnKernel &xlifepp::nabla_x(OperatorOnKernel&)

grad_x(opk)

nabla_y

OperatorOnKernel &xlifepp::nabla_y(const Kernel&)

grad_y(k)

OperatorOnKernel &xlifepp::nabla_y(OperatorOnKernel&)

grad_y(opk)

nablaG

OperatorOnUnknown &xlifepp::nablaG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)

nablaS

OperatorOnUnknown &xlifepp::nablaS(const Unknown &un)

Navier3d

Matrix<complex_t> xlifepp::Navier3d(const Point &x, const Point &y, Parameters &pa)

kernel computation : Phi(k_s; x, y)=1/mu(G(k_s; x, y)*I_3 + 1/k_s^2 * Hess(G(k_s; x, y)-G(k_p; x, y)))

value

Navier3dKernel

Kernel xlifepp::Navier3dKernel(const real_t &k, const real_t &lambda, const real_t &mu)

construct a Navier3d kernel

Kernel xlifepp::Navier3dKernel(Parameters& = defaultParameters)

construct a Navier3d kernel from parameters

Navier3dnxtensornxtimesNGr

Matrix<complex_t> xlifepp::Navier3dnxtensornxtimesNGr(const Point &x, const Point &y, Parameters &pa)

kernel computation : NxtensorNx(Phi)

NxtensorNxGr

Navier3dnxtensornxtimestracy

Matrix<complex_t> xlifepp::Navier3dnxtensornxtimestracy(const Point &x, const Point &y, Parameters &pa)

kernel computation : NxtensorNxTracy(Phi)

NxtensorNxTracy.

Navier3dTracx

Matrix<complex_t> xlifepp::Navier3dTracx(const Point &x, const Point &y, Parameters &pa)

kernel computation : Tracx(Phi)

tracx

Navier3dTracxy

Matrix<complex_t> xlifepp::Navier3dTracxy(const Point &x, const Point &y, Parameters &pa)

kernel computation : Tracxy(Phi)

tracx.tracy

Navier3dTracy

Matrix<complex_t> xlifepp::Navier3dTracy(const Point &x, const Point &y, Parameters &pa)

kernel computation : Tracy(Phi)

tracy

nbPar

int xlifepp::nbPar(const ITPARENTS &itpar)

nbSubDomainsIfScalar

number_t xlifepp::nbSubDomainsIfScalar(const std::vector<string_t> &sn, number_t nbSubDomains)

number_t xlifepp::nbSubDomainsIfScalar(string_t sn, number_t nbSubDomains)

ncross

OperatorOnFunction &xlifepp::ncross(const Function&)

n^f

OperatorOnUnknown &xlifepp::ncross(const Unknown &un)

OperatorOnFunction &xlifepp::ncross(OperatorOnFunction&)

n^opf

ncross_x

OperatorOnKernel &xlifepp::ncross_x(const Kernel&)

nx^k

OperatorOnKernel &xlifepp::ncross_x(OperatorOnKernel&)

nx^opk

ncross_y

OperatorOnKernel &xlifepp::ncross_y(const Kernel&)

ny^k

OperatorOnKernel &xlifepp::ncross_y(OperatorOnKernel&)

ny^opk

ncrosscurl

OperatorOnUnknown &xlifepp::ncrosscurl(const Unknown &un)

ncrosscurl_x

OperatorOnKernel &xlifepp::ncrosscurl_x(const Kernel&)

nx^curl_x(k)

OperatorOnKernel &xlifepp::ncrosscurl_x(OperatorOnKernel&)

nx^curl_x(opk)

ncrosscurl_y

OperatorOnKernel &xlifepp::ncrosscurl_y(const Kernel&)

ny^curl_y(k)

OperatorOnKernel &xlifepp::ncrosscurl_y(OperatorOnKernel&)

ny^curl_y(opk)

ncrossgrad

OperatorOnUnknown &xlifepp::ncrossgrad(const Unknown &un)

ncrossncross

OperatorOnFunction &xlifepp::ncrossncross(const Function&)

n^(n^f)

OperatorOnUnknown &xlifepp::ncrossncross(const Unknown &un)

OperatorOnFunction &xlifepp::ncrossncross(OperatorOnFunction&)

n^(n^opf)

ncrossncross_x

OperatorOnKernel &xlifepp::ncrossncross_x(const Kernel&)

nx^nx^k

OperatorOnKernel &xlifepp::ncrossncross_x(OperatorOnKernel&)

nx^nx^opk

ncrossncross_y

OperatorOnKernel &xlifepp::ncrossncross_y(const Kernel&)

ny^ny^k

OperatorOnKernel &xlifepp::ncrossncross_y(OperatorOnKernel&)

ny^ny^opk

ncrossndot

OperatorOnUnknown &xlifepp::ncrossndot(const Unknown&)

OperatorOnFunction &xlifepp::ncrossndot(Function&)

(n^n)|f

OperatorOnFunction &xlifepp::ncrossndot(OperatorOnFunction&)

(n^n)|opf

ncrossntimes

OperatorOnFunction &xlifepp::ncrossntimes(const Function &f)

OperatorOnUnknown &xlifepp::ncrossntimes(const Unknown &un)

OperatorOnFunction &xlifepp::ncrossntimes(Function&)

(n^n)*f

OperatorOnFunction &xlifepp::ncrossntimes(OperatorOnFunction&)

(n^n)*opf

ncrossrot

OperatorOnUnknown &xlifepp::ncrossrot(const Unknown &un)

ncrossrot_x

OperatorOnKernel &xlifepp::ncrossrot_x(const Kernel&)

nx^curl_x(k)

OperatorOnKernel &xlifepp::ncrossrot_x(OperatorOnKernel&)

nx^curl_x(opk)

ncrossrot_y

OperatorOnKernel &xlifepp::ncrossrot_y(const Kernel&)

ny^curl_y(k)

OperatorOnKernel &xlifepp::ncrossrot_y(OperatorOnKernel&)

ny^curl_y(opk)

ndiv

OperatorOnUnknown &xlifepp::ndiv(const Unknown &un)

ndiv_x

OperatorOnKernel &xlifepp::ndiv_x(const Kernel&)

nx*div_x(k)

OperatorOnKernel &xlifepp::ndiv_x(OperatorOnKernel&)

nx*div_x(opk)

ndiv_y

OperatorOnKernel &xlifepp::ndiv_y(const Kernel&)

ny*div_y(k)

OperatorOnKernel &xlifepp::ndiv_y(OperatorOnKernel&)

ny*div_y(opk)

ndot

OperatorOnFunction &xlifepp::ndot(const Function&)

n|f

OperatorOnUnknown &xlifepp::ndot(const Unknown &un)

OperatorOnFunction &xlifepp::ndot(OperatorOnFunction&)

n|opf

ndot_x

OperatorOnKernel &xlifepp::ndot_x(const Kernel&)

nx|k

OperatorOnKernel &xlifepp::ndot_x(OperatorOnKernel&)

nx|opk

ndot_y

OperatorOnKernel &xlifepp::ndot_y(const Kernel&)

ny|k

OperatorOnKernel &xlifepp::ndot_y(OperatorOnKernel&)

ny|opk

ndotgrad

OperatorOnUnknown &xlifepp::ndotgrad(const Unknown &un)

ndotgrad_x

OperatorOnKernel &xlifepp::ndotgrad_x(const Kernel&)

nx|grad_x(k)

OperatorOnKernel &xlifepp::ndotgrad_x(OperatorOnKernel&)

nx|grad_x(opk)

ndotgrad_y

OperatorOnKernel &xlifepp::ndotgrad_y(const Kernel&)

ny|grad_y(k)

OperatorOnKernel &xlifepp::ndotgrad_y(OperatorOnKernel&)

ny|grad_y(opk)

newSkyline

template<class M_>
M_ *xlifepp::newSkyline(const M_ *mat_p)

This function allocates a new matrix, equal to the input matrix but with a skyline storage.

Create a new matrix (especially a LargeMatrix) with a skyline storage.

The new matrix can then be factorized using one of the internal factorization algorithms available in XLiFE++, such as LDLt, LDL* or LU.

newton

template<typename T>
real_t xlifepp::newton(T (*f)(const T&), T (*fp)(const T&), T &x0, number_t niter = 100, real_t tol = theTolerance)

nlConj

inline complex_t xlifepp::nlConj(const complex_t &t)

inline real_t xlifepp::nlConj(const real_t &t)

nodesDim

number_t xlifepp::nodesDim(const Geometry &g)

noEvenDegreeRule

void xlifepp::noEvenDegreeRule(int degree, const string_t &name, ShapeType sh)

warning message

nonSeparatingEdge

std::pair<number_t, number_t> xlifepp::nonSeparatingEdge(const std::vector<Point> &p)

determines one edge of the polygon defined by its list of vertices that do not separate the polygon

determines an edge of a polygon so that the whole polygon is on the same side

norm

inline real_t xlifepp::norm(const complex_t &v)

inline real_t xlifepp::norm(const real_t &v)

norm of scalars

template<typename T>
real_t xlifepp::norm(const std::vector<T> &v)

norm of vector

real_t xlifepp::norm(const TermVector &tv, number_t l = 2)

vector norm

real_t xlifepp::norm(const VectorEntry&, number_t l = 2)

norm of Vector entry (default l2)

norm1

real_t xlifepp::norm1(const SuTermVector&)

l1 vector SuTermVector norm

real_t xlifepp::norm1(const TermVector &vt)

l1 TermVector norm

template<typename T>
real_t xlifepp::norm1(const Vector<T> &v)

real_t xlifepp::norm1(const VectorEntry&)

l1 vector VectorEntry norm

norm2

inline real_t xlifepp::norm2(const complex_t&)

template<typename T>
inline real_t xlifepp::norm2(const LargeMatrix<T> &A)

real_t xlifepp::norm2(const Matrix<complex_t> &m)

real_t xlifepp::norm2(const Matrix<Matrix<complex_t>> &m)

real_t xlifepp::norm2(const Matrix<Matrix<real_t>> &m)

real_t xlifepp::norm2(const Matrix<real_t> &m)

specialization of norm2

real_t xlifepp::norm2(const Point&)

returns the square distance between 2 points

inline real_t xlifepp::norm2(const real_t&)

real_t xlifepp::norm2(const SuTermVector&)

l2 vector SuTermVector norm (quadratic norm)

inline real_t xlifepp::norm2(const TermMatrix &A)

real_t xlifepp::norm2(const TermVector &vt)

l2 TermVector norm (quadratic norm)

template<typename T>
real_t xlifepp::norm2(const Vector<T> &v)

norm of Vector, extern forms

real_t xlifepp::norm2(const VectorEntry&)

l2 vector VectorEntry (quadratic norm)

normal_Piecewise

inline Vector<real_t> xlifepp::normal_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

normalBoxMuller

real_t xlifepp::normalBoxMuller(real_t mu = 0., real_t sigma = 1.)

normal distribution (mu,sigma) using Box Muller method (using rand())

normalDistribution

void xlifepp::normalDistribution(complex_t *mat, number_t n = 1, number_t m = 1)

compute a complex Gaussian matrix normal distribution (0,1) (using <random> if C11)

void xlifepp::normalDistribution(complex_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)

compute a complex Gaussian matrix normal distribution (mu,sigma) (using <random> if C11)

template<typename T>
std::vector<T> xlifepp::normalDistribution(number_t n, number_t m, real_t mu = 0., real_t sigma = 1.)

template<typename T>
std::vector<T> xlifepp::normalDistribution(number_t n, real_t mu = 0., real_t sigma = 1.)

void xlifepp::normalDistribution(real_t *mat, number_t n = 1, number_t m = 1)

compute a Gaussian matrix normal distribution (0,1) (using <random> if C11)

void xlifepp::normalDistribution(real_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)

compute a Gaussian matrix normal distribution (mu,sigma) (using <random> if C11)

real_t xlifepp::normalDistribution(real_t mu = 0., real_t sigma = 1., GaussianGenerator gg = _MarsagliaGenerator)

return a sample from normal distribution (mu,sigma) (using <random> if C11)

template<typename T>
void xlifepp::normalDistribution(std::vector<T> &mat, number_t n, number_t m, real_t mu = 0., real_t sigma = 1.)

template<typename T>
void xlifepp::normalDistribution(std::vector<T> &v, real_t mu = 0., real_t sigma = 1.)

normalDistributionC

void xlifepp::normalDistributionC(complex_t *mat, GaussianGenerator gg, number_t n = 1, number_t m = 1)

compute a complex Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(complex_t *mat, number_t n = 1, number_t m = 1)

compute a complex Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(complex_t *mat, real_t mu, real_t sigma, GaussianGenerator gg, number_t n = 1, number_t m = 1)

compute a complex Gaussian matrix normal distribution (mu,sigma) (using rand())

void xlifepp::normalDistributionC(complex_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)

compute a complex Gaussian matrix normal distribution (mu,sigma) (using rand())

void xlifepp::normalDistributionC(real_t *mat, GaussianGenerator gg, number_t n = 1, number_t m = 1)

compute a Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(real_t *mat, number_t n = 1, number_t m = 1)

compute a Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(real_t *mat, real_t mu, real_t sigma, GaussianGenerator gg, number_t n = 1, number_t m = 1)

compute a Gaussian matrix normal distribution (mu,sigma) (using rand())

void xlifepp::normalDistributionC(real_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)

compute a Gaussian matrix normal distribution (mu,sigma) (using rand())

real_t xlifepp::normalDistributionC(real_t mu = 0., real_t sigma = 1., GaussianGenerator gg = _MarsagliaGenerator)

return a sample from normal distribution (mu,sigma) (using rand())

normalizeEigenVectors

template<typename T>
MatrixEigenDense<T> xlifepp::normalizeEigenVectors(const MatrixEigenDense<T> &eigVecs)

normalMarsaglia

double xlifepp::normalMarsaglia(real_t mu = 0., real_t sigma = 1.)

normal distribution (mu,sigma) using Marsaglia method (using rand())

normalsOn

TermVector xlifepp::normalsOn(GeomDomain &dom, const Unknown &u)

compute normals of a side domain using interpolation given by an unknown

normalVectorFromParameters

inline Vector<real_t> &xlifepp::normalVectorFromParameters(const Parameters &pa)

extract normal vector from Parameters

norminfty

inline real_t xlifepp::norminfty(const complex_t &z)

template<typename T>
inline real_t xlifepp::norminfty(const LargeMatrix<T> &A)

real_t xlifepp::norminfty(const Matrix<complex_t> &m)

real_t xlifepp::norminfty(const Matrix<Matrix<complex_t>> &m)

real_t xlifepp::norminfty(const Matrix<Matrix<real_t>> &m)

real_t xlifepp::norminfty(const Matrix<real_t> &m)

specialization of infinite norm

inline real_t xlifepp::norminfty(const real_t &r)

real_t xlifepp::norminfty(const SuTermVector&)

l_infinite SuTermVector norm (sup norm)

inline real_t xlifepp::norminfty(const TermMatrix &A)

real_t xlifepp::norminfty(const TermVector &vt)

l_infinite TermVector norm (sup norm)

template<typename T>
real_t xlifepp::norminfty(const Vector<T> &v)

real_t xlifepp::norminfty(const VectorEntry&)

l_infinite VectorEntry (sup norm)

ntimes

OperatorOnFunction &xlifepp::ntimes(const Function&)

n*f

OperatorOnFunction &xlifepp::ntimes(OperatorOnFunction&)

n*opf

ntimes_x

OperatorOnKernel &xlifepp::ntimes_x(const Kernel&)

nx*k

OperatorOnKernel &xlifepp::ntimes_x(OperatorOnKernel &opk)

nx*opk

ntimes_y

OperatorOnKernel &xlifepp::ntimes_y(const Kernel&)

ny*k

OperatorOnKernel &xlifepp::ntimes_y(OperatorOnKernel &opk)

ny*opk

ntimesndot

OperatorOnUnknown &xlifepp::ntimesndot(const Unknown &un)

numberingConversion

template<class ST_>
const vector<number_t> xlifepp::numberingConversion(const number_t order)

The following function returns a vector giving the correspondence between the two numberings of the points of the Lagrange mesh of order k over the reference element (triangle or quadrangle).

The following function returns a vector giving the correspondence between the two numberings of the points of the Lagrange mesh of order k over the reference element (tetrahedron or hexahedron).

Provided V is the returned vector, if i denotes the rank of a point in XLiFE++, then the corresponding point is V[i] in class subdivision::TriangleMesh or subdivision::QuadrangleMesh, referred to as xxxMesh in the following.

Provided V is the returned vector, if i denotes the rank of a point in XLiFE++ then the corresponding point is V[i] in class subdivision::TetrahedronMesh or subdivision::HexahedronMesh, referred to as xxxMesh in the following.

numberOfCols

number_t xlifepp::numberOfCols(const complex_t &v)

template<typename T>
number_t xlifepp::numberOfCols(const Matrix<T> &m)

number_t xlifepp::numberOfCols(const real_t &v)

numberOfRows

number_t xlifepp::numberOfRows(const complex_t &v)

template<typename T>
number_t xlifepp::numberOfRows(const Matrix<T> &m)

number_t xlifepp::numberOfRows(const real_t &v)

numberOfThreads

number_t xlifepp::numberOfThreads(int n)

manage the number of threads in OpenMP if n==0 set to the maximum of number of threads if n >0 set the number of threads to n if n==-1 return the number of threads (default) if omp is not available, always return 1

if omp is available, set or get the number of threads (default)

numToDim

inline dimen_t xlifepp::numToDim(number_t n, string_t loc = "?")

numToInt

inline int_t xlifepp::numToInt(number_t n, string_t loc = "?")

nx

OperatorOnUnknown &xlifepp::nx(const Unknown &un)

nxcrossny_cross

OperatorOnKernel &xlifepp::nxcrossny_cross(const Kernel&)

(nx^ny)^k

OperatorOnKernel &xlifepp::nxcrossny_cross(OperatorOnKernel&)

(nx^ny)^opk

Parameters:

opk – (nx.ny).opk

nxcrossny_dot

OperatorOnKernel &xlifepp::nxcrossny_dot(const Kernel&)

(nx^ny).k

OperatorOnKernel &xlifepp::nxcrossny_dot(OperatorOnKernel&)

(nx^ny).opk

Parameters:

opk – (nx.ny).opk

nxdotny_times

OperatorOnKernel &xlifepp::nxdotny_times(const Kernel&)

(nx.ny)*k

OperatorOnKernel &xlifepp::nxdotny_times(OperatorOnKernel&)

(nx.ny)*opk

Parameters:

opk – (nx.ny)*opk

nxtensornxtimesNGr

OperatorOnKernel &xlifepp::nxtensornxtimesNGr(const Kernel&)

(nxtensornx)*Id(k)

nxtensornxtimestrac_y

OperatorOnKernel &xlifepp::nxtensornxtimestrac_y(const Kernel&)

(nxtensornx)*trac_y(k)

nycrossnx_cross

OperatorOnKernel &xlifepp::nycrossnx_cross(const Kernel&)

(ny^ny)^k

OperatorOnKernel &xlifepp::nycrossnx_cross(OperatorOnKernel&)

(ny^nx)^opk

Parameters:

opk – (nx.ny).opk

nycrossnx_dot

OperatorOnKernel &xlifepp::nycrossnx_dot(const Kernel&)

(ny^nx).k

OperatorOnKernel &xlifepp::nycrossnx_dot(OperatorOnKernel&)

(ny^nx).opk

Parameters:

opk – (nx.ny).opk

ode45

template<typename T>
std::pair<Vector<real_t>, Vector<T>> xlifepp::ode45(T &(*f)(real_t, const T&, T&), real_t a, real_t b, real_t dt, const T &y0, number_t nbt, real_t mins, real_t maxs, real_t prec = 1.E-6)

template<typename T>
std::pair<Vector<real_t>, Vector<T>> xlifepp::ode45(T &(*f)(real_t, const T&, T&), real_t a, real_t b, real_t dt, const T &y0, real_t prec = 1.E-6)

template<typename T, typename P>
std::pair<Vector<real_t>, Vector<T>> xlifepp::ode45(T &(*f)(real_t, const T&, T&, P&), real_t a, real_t b, real_t dt, const T &y0, P &pars, number_t nbt, real_t mins, real_t maxs, real_t prec = 1.E-6)

template<typename T, typename P>
std::pair<Vector<real_t>, Vector<T>> xlifepp::ode45(T &(*f)(real_t, const T&, T&, P&), real_t a, real_t b, real_t dt, const T &y0, P &pars, real_t prec = 1.E-6)

on

EssentialCondition xlifepp::on(GeomDomain&, const EssentialCondition&)

set domain to a Essential condition

oneOfStrings

string_t xlifepp::oneOfStrings(const std::vector<string_t> &sn, int i)

string_t xlifepp::oneOfStrings(const string_t &sn, int i)

oneOfStringsIfVector

string_t xlifepp::oneOfStringsIfVector(const std::vector<string_t> &sn, int i)

string_t xlifepp::oneOfStringsIfVector(const string_t &sn, int i)

openCrack

inline void xlifepp::openCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, Geometry &g6, Geometry &g7, string_t domNameToOpen)

user shortcut to crack 7 geometries

inline void xlifepp::openCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, Geometry &g6, string_t domNameToOpen)

user shortcut to crack 6 geometries

inline void xlifepp::openCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, Geometry &g5, string_t domNameToOpen)

user shortcut to crack 5 geometries

inline void xlifepp::openCrack(Geometry &g1, Geometry &g2, Geometry &g3, Geometry &g4, string_t domNameToOpen)

user shortcut to crack 4 geometries

inline void xlifepp::openCrack(Geometry &g1, Geometry &g2, Geometry &g3, string_t domNameToOpen)

user shortcut to crack 3 geometries

inline void xlifepp::openCrack(Geometry &g1, Geometry &g2, string_t domNameToOpen)

user shortcut to crack 2 geometries

inline void xlifepp::openCrack(Geometry &g1, string_t domNameToOpen)

user shortcut to crack one geometry

operator!

inline SymbolicFunction &xlifepp::operator!(const SymbolicFunction &f)

operator!=

inline SymbolicFunction &xlifepp::operator!=(const complex_t &c, const SymbolicFunction &f)

inline bool xlifepp::operator!=(const DifferentialOperator &d1, const DifferentialOperator &d2)

bool xlifepp::operator!=(const DofComponent&, const DofComponent&)

diffference

bool xlifepp::operator!=(const DomUnkDop&, const DomUnkDop&)

difference

bool xlifepp::operator!=(const Function&, const Function&)

compare functions (same fun and params pointers)

template<typename K>
bool xlifepp::operator!=(const Matrix<K> &a, const Matrix<K> &b)

matrix comparison (element by element)

template<typename K>
bool xlifepp::operator!=(const MonomialT<K> &m1, const MonomialT<K> &m2)

bool xlifepp::operator!=(const Operand&, const Operand&)

compare Operands

bool xlifepp::operator!=(const OperatorOnFunction&, const OperatorOnFunction&)

different operator on function

bool xlifepp::operator!=(const OperatorOnKernel&, const OperatorOnKernel&)

different operator on kernel

bool xlifepp::operator!=(const OperatorOnUnknown&, const OperatorOnUnknown&)

compare OperatorOnUnknown (same unknowns, same diff operators, same functions …)

bool xlifepp::operator!=(const Point&, const Point&)

not equality of two points

inline SymbolicFunction &xlifepp::operator!=(const real_t &r, const SymbolicFunction &f)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP>
inline bool xlifepp::operator!=(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, SmartPointerNullType rhs)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator!=(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, U *rhs)

template<typename K>
bool xlifepp::operator!=(const SparseMatrix<K> &a, const SparseMatrix<K> &b)

matrix comparison (element by element)

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)

template<class K>
bool xlifepp::operator!=(const Triplet<K> &t1, const Triplet<K> &t2)

bool xlifepp::operator!=(const Value&, const Value&)

compare values

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP>
inline bool xlifepp::operator!=(SmartPointerNullType lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator!=(U *lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T>
inline ComparisonFunction<T> xlifepp::operator!=(VarComparison, const T &a)

operator%

OperatorOnUnknown &xlifepp::operator%(const complex_t&, const Unknown&)

cu

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

OperatorOnUnknown &xlifepp::operator%(const Function&, const Unknown&)

Fu.

OperatorOnUnknown &xlifepp::operator%(const Function&, OperatorOnUnknown&)

contracted product syntax FOp(u)

KernelOperatorOnUnknowns xlifepp::operator%(const Kernel&, const OperatorOnUnknown&)

ker % opv

KernelOperatorOnUnknowns xlifepp::operator%(const Kernel&, const Unknown&)

ker % v

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

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)

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

Matrixu.

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

OperatorOnUnknown &xlifepp::operator%(const OperatorOnFunction&, const Unknown&)

op(F)u

OperatorOnUnknown &xlifepp::operator%(const OperatorOnFunction&, OperatorOnUnknown&)

contracted product syntax op(F)FOp(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)

OperatorOnUnknown &xlifepp::operator%(const real_t&, const Unknown&)

ru

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

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

tv % ker

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

tv % opker

OperatorOnUnknown &xlifepp::operator%(const TermVector &tv, const TestFunction &un)

tvu

OperatorOnUnknown &xlifepp::operator%(const TermVector &tv, const Unknown &un)

tvu

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

tvopu

OperatorOnUnknown &xlifepp::operator%(const TestFunction &un, const TermVector &tv)

utv

OperatorOnUnknown &xlifepp::operator%(const Unknown&, const complex_t&)

uc

OperatorOnUnknown &xlifepp::operator%(const Unknown&, const Function&)

uF

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

uop(F)

OperatorOnUnknown &xlifepp::operator%(const Unknown&, const real_t&)

ur

OperatorOnUnknown &xlifepp::operator%(const Unknown&, const Value&)

uval

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

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

uMatrix

OperatorOnUnknown &xlifepp::operator%(const Unknown &un, const TermVector &tv)

utv

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

uVector

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

valu

OperatorOnUnknown &xlifepp::operator%(const Value&, OperatorOnUnknown&)

contracted product syntax VOp(u)

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

Vectoru.

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

OperatorOnUnknown &xlifepp::operator%(OperatorOnUnknown&, const Function&)

contracted product syntax Op(u)F

OperatorOnUnknown &xlifepp::operator%(OperatorOnUnknown&, const OperatorOnFunction&)

contracted product syntax Op(u)op(F)

OperatorOnUnknown &xlifepp::operator%(OperatorOnUnknown&, const Value&)

contracted product syntax Op(u)V

OperatorOnUnknowns xlifepp::operator%(OperatorOnUnknown&, OperatorOnUnknown&)

opu % opv

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)

oputv

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)

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

OperatorOnUnknowns xlifepp::operator%(Unknown&, OperatorOnUnknown&)

u % opv

OperatorOnUnknowns xlifepp::operator%(Unknown&, Unknown&)

u % v

operator&

EssentialConditions xlifepp::operator&(const EssentialCondition&, const EssentialCondition&)

bcs = ec & ec

EssentialConditions xlifepp::operator&(const EssentialCondition&, const EssentialConditions&)

bcs = ec & ecs

EssentialConditions xlifepp::operator&(const EssentialConditions&, const EssentialCondition&)

bcs = ecs & ec

EssentialConditions xlifepp::operator&(const EssentialConditions&, const EssentialConditions&)

bcs = ecs & ecs

operator&&

template<typename T>
ComparisonFunction<T> xlifepp::operator&&(const ComparisonFunction<T> &cof1, const ComparisonFunction<T> &cof2)

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

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

Warning

doxygenfunction: Unable to resolve function “xlifepp::operator*” with arguments (const TermMatrix&, const T&) in doxygen xml output for project “xlifepp” from directory: ../../xlifepp/doc/xml/. Potential matches:

- BasicBilinearForm &operator*(const BasicBilinearForm&, const BasicBilinearForm&)
- BilinearForm operator*(const BilinearForm&, const BilinearForm&)
- BilinearForm operator*(const BilinearForm&, const complex_t&)
- BilinearForm operator*(const BilinearForm&, const int&)
- BilinearForm operator*(const BilinearForm&, const int_t&)
- BilinearForm operator*(const BilinearForm&, const number_t&)
- BilinearForm operator*(const BilinearForm&, const real_t&)
- BilinearForm operator*(const complex_t&, const BilinearForm&)
- BilinearForm operator*(const int&, const BilinearForm&)
- BilinearForm operator*(const int_t&, const BilinearForm&)
- BilinearForm operator*(const number_t&, const BilinearForm&)
- BilinearForm operator*(const real_t&, const BilinearForm&)
- KernelOperatorOnTermVector operator*(const Kernel &ker, const TermVector &tv)
- KernelOperatorOnTermVector operator*(const OperatorOnKernel &opk, const TermVector &tv)
- KernelOperatorOnTermVector operator*(const TermVector &tv, const Kernel &ker)
- KernelOperatorOnTermVector operator*(const TermVector &tv, const OperatorOnKernel &opker)
- KernelOperatorOnTermVectorAndUnknown operator*(const KernelOperatorOnTermVector &koptv, const OperatorOnUnknown &opv)
- KernelOperatorOnTermVectorAndUnknown operator*(const KernelOperatorOnTermVector &koptv, const Unknown &v)
- KernelOperatorOnTermVectorAndUnknown operator*(const KernelOperatorOnTermVectorAndUnknown&, const OperatorOnUnknown&)
- KernelOperatorOnTermVectorAndUnknown operator*(const OperatorOnUnknown &opv, const KernelOperatorOnTermVector &koptv)
- KernelOperatorOnTermVectorAndUnknown operator*(const OperatorOnUnknown&, const KernelOperatorOnTermVectorAndUnknown&)
- KernelOperatorOnTermVectorAndUnknown operator*(const Unknown &v, const KernelOperatorOnTermVector &koptv)
- KernelOperatorOnUnknowns operator*(const Kernel&, const OperatorOnUnknown&)
- KernelOperatorOnUnknowns operator*(const Kernel&, const Unknown&)
- KernelOperatorOnUnknowns operator*(const KernelOperatorOnUnknowns&, const OperatorOnUnknown&)
- KernelOperatorOnUnknowns operator*(const KernelOperatorOnUnknowns&, const Unknown&)
- KernelOperatorOnUnknowns operator*(const OperatorOnKernel&, const OperatorOnUnknown&)
- KernelOperatorOnUnknowns operator*(const OperatorOnUnknown&, const Kernel&)
- KernelOperatorOnUnknowns operator*(const OperatorOnUnknown&, const KernelOperatorOnUnknowns&)
- KernelOperatorOnUnknowns operator*(const OperatorOnUnknown&, const OperatorOnKernel&)
- KernelOperatorOnUnknowns operator*(const Unknown&, const Kernel&)
- KernelOperatorOnUnknowns operator*(const Unknown&, const KernelOperatorOnUnknowns&)
- LargeMatrix<Matrix<complex_t>> operator*(const LargeMatrix<Matrix<complex_t>> &mA, const LargeMatrix<Matrix<real_t>> &mB)
- LargeMatrix<Matrix<complex_t>> operator*(const LargeMatrix<Matrix<real_t>> &mA, const LargeMatrix<Matrix<complex_t>> &mB)
- LargeMatrix<complex_t> operator*(const LargeMatrix<complex_t> &mA, const LargeMatrix<real_t> &mB)
- LargeMatrix<complex_t> operator*(const LargeMatrix<complex_t> &mat, const real_t v)
- LargeMatrix<complex_t> operator*(const LargeMatrix<real_t> &mA, const LargeMatrix<complex_t> &mB)
- LargeMatrix<complex_t> operator*(const LargeMatrix<real_t> &mat, const complex_t v)
- LargeMatrix<complex_t> operator*(const complex_t v, const LargeMatrix<real_t> &mat)
- LargeMatrix<complex_t> operator*(const real_t v, const LargeMatrix<complex_t> &mat)
- LcKernelOperatorOnUnknowns operator*(const LcKernelOperatorOnUnknowns &lc, const complex_t &a)
- LcKernelOperatorOnUnknowns operator*(const LcKernelOperatorOnUnknowns &lc, const real_t &a)
- LcKernelOperatorOnUnknowns operator*(const complex_t &a, const LcKernelOperatorOnUnknowns &lc)
- LcKernelOperatorOnUnknowns operator*(const real_t &a, const LcKernelOperatorOnUnknowns &lc)
- LcOperatorOnUnknown operator*(const LcOperatorOnUnknown &lc, const complex_t &a)
- LcOperatorOnUnknown operator*(const LcOperatorOnUnknown &lc, const real_t &a)
- LcOperatorOnUnknown operator*(const complex_t &a, const LcOperatorOnUnknown &lc)
- LcOperatorOnUnknown operator*(const real_t &a, const LcOperatorOnUnknown &lc)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknown &lcopu, const LcOperatorOnUnknown &lcopv)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknown &lcopu, const OperatorOnUnknown &opv)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknown &lcopu, const Unknown &v)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknowns &lc, const complex_t &a)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknowns &lc, const real_t &a)
- LcOperatorOnUnknowns operator*(const OperatorOnUnknown &opu, const LcOperatorOnUnknown &lcopv)
- LcOperatorOnUnknowns operator*(const Unknown &u, const LcOperatorOnUnknown &lcopv)
- LcOperatorOnUnknowns operator*(const complex_t &a, const LcOperatorOnUnknowns &lc)
- LcOperatorOnUnknowns operator*(const real_t &a, const LcOperatorOnUnknowns &lc)
- LinearForm operator*(const LinearForm&, const complex_t&)
- LinearForm operator*(const LinearForm&, const int&)
- LinearForm operator*(const LinearForm&, const int_t&)
- LinearForm operator*(const LinearForm&, const number_t&)
- LinearForm operator*(const LinearForm&, const real_t&)
- LinearForm operator*(const complex_t&, const LinearForm&)
- LinearForm operator*(const int&, const LinearForm&)
- LinearForm operator*(const int_t&, const LinearForm&)
- LinearForm operator*(const number_t&, const LinearForm&)
- LinearForm operator*(const real_t&, const LinearForm&)
- Matrix<complex_t> operator*(const Matrix<complex_t> &cA, const Matrix<real_t> &rB)
- Matrix<complex_t> operator*(const Matrix<real_t> &rA, const Matrix<complex_t> &cB)
- Matrix<complex_t> operator*(const Matrix<real_t> &rA, const complex_t &x)
- Matrix<complex_t> operator*(const complex_t &x, const Matrix<real_t> &rA)
- MatrixEntry operator*(const MatrixEntry&, const MatrixEntry&)
- OperatorOnFunction &operator*(OperatorOnFunction&, UnitaryVector)
- OperatorOnFunction &operator*(UnitaryVector n, const Matrix<complex_t> &v)
- OperatorOnFunction &operator*(UnitaryVector n, const Matrix<real_t> &v)
- OperatorOnFunction &operator*(UnitaryVector n, const complex_t &v)
- OperatorOnFunction &operator*(UnitaryVector n, const real_t &v)
- OperatorOnFunction &operator*(UnitaryVector, OperatorOnFunction&)
- OperatorOnFunction &operator*(UnitaryVector, const Function&)
- OperatorOnFunction &operator*(const Extension &e, OperatorOnFunction &opf)
- OperatorOnFunction &operator*(const Extension &e, const Function &f)
- OperatorOnFunction &operator*(const Function&, UnitaryVector)
- OperatorOnFunction &operator*(const Matrix<complex_t> &v, UnitaryVector n)
- OperatorOnFunction &operator*(const Matrix<real_t> &v, UnitaryVector n)
- OperatorOnFunction &operator*(const complex_t &v, UnitaryVector n)
- OperatorOnFunction &operator*(const real_t &v, UnitaryVector n)
- OperatorOnKernel &operator*(OperatorOnKernel&, UnitaryVector)
- OperatorOnKernel &operator*(UnitaryVector, OperatorOnKernel&)
- OperatorOnKernel &operator*(UnitaryVector, const Kernel&)
- OperatorOnKernel &operator*(const Extension &e, OperatorOnKernel &opk)
- OperatorOnKernel &operator*(const Extension &e, const Kernel &k)
- OperatorOnKernel &operator*(const Kernel&, UnitaryVector)
- OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const TermVector &tv)
- OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const complex_t &val)
- OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const real_t &val)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, UnitaryVector)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, const Function&)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, const OperatorOnFunction&)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, const Value&)
- OperatorOnUnknown &operator*(UnitaryVector, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(UnitaryVector, const Unknown&)
- OperatorOnUnknown &operator*(const Function&, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(const Function&, const Unknown&)
- OperatorOnUnknown &operator*(const OperatorOnFunction&, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(const OperatorOnFunction&, const Unknown&)
- OperatorOnUnknown &operator*(const TermVector &tv, OperatorOnUnknown &opu)
- OperatorOnUnknown &operator*(const TermVector &tv, const TestFunction &un)
- OperatorOnUnknown &operator*(const TermVector &tv, const Unknown &un)
- OperatorOnUnknown &operator*(const TestFunction &un, const TermVector &tv)
- OperatorOnUnknown &operator*(const Unknown &un, const TermVector &tv)
- OperatorOnUnknown &operator*(const Unknown&, UnitaryVector)
- OperatorOnUnknown &operator*(const Unknown&, const Function&)
- OperatorOnUnknown &operator*(const Unknown&, const OperatorOnFunction&)
- OperatorOnUnknown &operator*(const Unknown&, const Value&)
- OperatorOnUnknown &operator*(const Unknown&, const complex_t&)
- OperatorOnUnknown &operator*(const Unknown&, const real_t&)
- OperatorOnUnknown &operator*(const Value&, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(const Value&, const Unknown&)
- OperatorOnUnknown &operator*(const complex_t &val, OperatorOnUnknown &opu)
- OperatorOnUnknown &operator*(const complex_t&, const Unknown&)
- OperatorOnUnknown &operator*(const real_t &val, OperatorOnUnknown &opu)
- OperatorOnUnknown &operator*(const real_t&, const Unknown&)
- OperatorOnUnknowns operator*(OperatorOnUnknown&, OperatorOnUnknown&)
- OperatorOnUnknowns operator*(OperatorOnUnknown&, Unknown&)
- OperatorOnUnknowns operator*(Unknown&, OperatorOnUnknown&)
- OperatorOnUnknowns operator*(Unknown&, Unknown&)
- Parameter operator*(const Parameter &p, const complex_t &v)
- Parameter operator*(const Parameter &p, const int v)
- Parameter operator*(const Parameter &p, const int_t v)
- Parameter operator*(const Parameter &p, const number_t v)
- Parameter operator*(const Parameter &p, const real_t v)
- Parameter operator*(const Parameter &p1, const Parameter &p2)
- Parameter operator*(const complex_t &v, const Parameter &p)
- Parameter operator*(const int v, const Parameter &p)
- Parameter operator*(const int_t v, const Parameter &p)
- Parameter operator*(const number_t v, const Parameter &p)
- Parameter operator*(const real_t v, const Parameter &p)
- Point operator*(const Point&, const real_t)
- Point operator*(const real_t, const Point&)
- SuBilinearForm operator*(const SuBilinearForm&, const complex_t&)
- SuBilinearForm operator*(const complex_t&, const SuBilinearForm&)
- SuLinearForm operator*(const SuLinearForm &sulf, const complex_t &c)
- SuLinearForm operator*(const complex_t &c, const SuLinearForm &sulf)
- SuTermMatrix operator*(const SuTermMatrix&, const SuTermMatrix&)
- SuTermVector operator*(const SuTermMatrix &sutM, const SuTermVector &sutV)
- SuTermVector operator*(const SuTermVector &s1, const SuTermVector &s2)
- SuTermVector operator*(const SuTermVector &sutV, const SuTermMatrix &sutM)
- SymbolicFunction &operator*(const SymbolicFunction &f, const complex_t &c)
- SymbolicFunction &operator*(const SymbolicFunction &f, const real_t &r)
- SymbolicFunction &operator*(const SymbolicFunction &f1, const SymbolicFunction &f2)
- SymbolicFunction &operator*(const complex_t &c, const SymbolicFunction &f)
- SymbolicFunction &operator*(const real_t &r, const SymbolicFunction &f)
- SymbolicTermMatrix &operator*(LcTerm<TermMatrix> &LC, SymbolicTermMatrix &S)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S, LcTerm<TermMatrix> &LC)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S, const TermMatrix &M)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S, const complex_t &c)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S1, SymbolicTermMatrix &S2)
- SymbolicTermMatrix &operator*(const TermMatrix &M, SymbolicTermMatrix &S)
- SymbolicTermMatrix &operator*(const complex_t &c, SymbolicTermMatrix &S)
- TermMatrix operator*(const TermMatrix&, const TermMatrix&)
- TermVector operator*(const LcTerm<TermMatrix>&, const TermVector&)
- TermVector operator*(const Projector &P, const TermVector &X)
- TermVector operator*(const SymbolicTermMatrix &S, const TermVector &X)
- TermVector operator*(const TermMatrix &tM, const LcTerm<TermVector> &lctv)
- TermVector operator*(const TermMatrix&, const TermVector&)
- TermVector operator*(const TermVector &X, const SymbolicTermMatrix &S)
- TermVector operator*(const TermVector &s1, const TermVector &s2)
- TermVector operator*(const TermVector&, const TermMatrix&)
- Transformation operator*(const Transformation &t1, const Transformation &t2)
- Vector<Matrix<complex_t>> operator*(const real_t &x, const Vector<Matrix<complex_t>> &a)
- Vector<Vector<complex_t>> operator*(const Vector<Vector<complex_t>>&, const complex_t&)
- Vector<Vector<complex_t>> operator*(const complex_t&, const Vector<Vector<complex_t>>&)
- Vector<complex_t> operator*(const Matrix<complex_t> &cA, const Vector<real_t> &rV)
- Vector<complex_t> operator*(const Matrix<real_t> &rA, const Vector<complex_t> &cV)
- Vector<complex_t> operator*(const Vector<complex_t> &cA, const real_t &x)
- Vector<complex_t> operator*(const Vector<complex_t> &cV, const Matrix<real_t> &rA)
- Vector<complex_t> operator*(const Vector<real_t> &rA, const complex_t &x)
- Vector<complex_t> operator*(const Vector<real_t> &rV, const Matrix<complex_t> &cA)
- Vector<complex_t> operator*(const complex_t &x, const Vector<real_t> &rA)
- Vector<complex_t> operator*(const real_t &x, const Vector<complex_t> &cA)
- VectorEntry operator*(const MatrixEntry &mat, const VectorEntry &vec)
- VectorEntry operator*(const VectorEntry &vec, const MatrixEntry &mat)
- complex_t operator*(const complex_t &z, const int i)
- complex_t operator*(const complex_t &z, const int_t i)
- complex_t operator*(const complex_t &z, const number_t n)
- complex_t operator*(const int i, const complex_t &z)
- complex_t operator*(const int_t i, const complex_t &z)
- complex_t operator*(const number_t n, const complex_t &z)
- real_t operator*(real_t a, const AngleUnit &u)
- std::vector<Vector<complex_t>> operator*(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec)
- std::vector<Vector<complex_t>> operator*(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec)
- std::vector<Vector<complex_t>> operator*(const std::vector<Vector<complex_t>> &vec, const LargeMatrix<Matrix<real_t>> &mat)
- std::vector<Vector<complex_t>> operator*(const std::vector<Vector<real_t>> &vec, const LargeMatrix<Matrix<complex_t>> &mat)
- std::vector<complex_t> operator*(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec)
- std::vector<complex_t> operator*(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec)
- std::vector<complex_t> operator*(const std::vector<complex_t> &vec, const LargeMatrix<real_t> &mat)
- std::vector<complex_t> operator*(const std::vector<real_t> &vec, const LargeMatrix<complex_t> &mat)
- template<typename K, typename KK> Matrix<K> operator*(const KK &x, const Matrix<K> &a)
- template<typename K, typename KK> SparseMatrix<K> operator*(const KK &x, const SparseMatrix<K> &a)
- template<typename K, typename KK> SparseMatrix<K> operator*(const SparseMatrix<K> &a, const KK &x)
- template<typename K, typename KK> VectorEigenDense<K> operator*(const KK &k, const VectorEigenDense<K> &vec)
- template<typename K, typename KK> VectorEigenDense<K> operator*(const VectorEigenDense<K> &vec, const KK &k)
- template<typename K, typename V> Vector<K> operator*(const Matrix<K> &m, const Vector<V> &v)
- template<typename K, typename V> Vector<K> operator*(const SparseMatrix<K> &m, const std::vector<V> &v)
- template<typename K, typename V> Vector<K> operator*(const Vector<V> &v, const Matrix<K> &m)
- template<typename K, typename V> Vector<K> operator*(const std::vector<V> &v, const SparseMatrix<K> &m)
- template<typename K> Matrix<K> operator*(const Matrix<K> &a, const K &x)
- template<typename K> Matrix<K> operator*(const Matrix<K> &a, const Matrix<K> &b)
- template<typename K> MonomialT<K> operator*(const MonomialT<K> &m1, const MonomialT<K> &m2)
- template<typename K> PolynomialBasisT<K> operator*(const PolynomialBasisT<K> &p, const PolynomialBasisT<K> &q)
- template<typename K> PolynomialT<K> operator*(const K &k, const MonomialT<K> &m)
- template<typename K> PolynomialT<K> operator*(const K &k, const PolynomialT<K> &p)
- template<typename K> PolynomialT<K> operator*(const MonomialT<K> &m, const K &k)
- template<typename K> PolynomialT<K> operator*(const MonomialT<K> &m, const PolynomialT<K> &p)
- template<typename K> PolynomialT<K> operator*(const PolynomialT<K> &p, const K &k)
- template<typename K> PolynomialT<K> operator*(const PolynomialT<K> &p, const MonomialT<K> &m)
- template<typename K> PolynomialT<K> operator*(const PolynomialT<K> &p1, const PolynomialT<K> &p2)
- template<typename K> PolynomialsBasisT<K> operator*(const Matrix<K> &mat, const PolynomialsBasisT<K> &ps)
- template<typename K> PolynomialsBasisT<K> operator*(const PolynomialBasisT<K> &pb, const std::vector<MonomialT<K>> &vp)
- template<typename K> Vector<K> operator*(const K &x, const Vector<K> &a)
- template<typename K> Vector<K> operator*(const Vector<K> &a, const K &x)
- template<typename K> Vector<K> operator*(const Vector<K> &a, const Vector<K> &b)
- template<typename K> Vector<Matrix<K>> operator*(const K &x, const Vector<Matrix<K>> &a)
- template<typename K> std::vector<PolynomialT<K>> operator*(const Matrix<K> &mat, const std::vector<PolynomialT<K>> &ps)
- template<typename T, typename I> Vector<T> operator*(const HMatrix<T, I> &h, const Vector<T> &x)
- template<typename T> KernelOperatorOnUnknowns operator*(T (*fun)(const Point&, const Point&, Parameters&), const Unknown &un)
- template<typename T> KernelOperatorOnUnknowns operator*(T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&), const Unknown &un)
- template<typename T> KernelOperatorOnUnknowns operator*(const Unknown &un, T (*fun)(const Point&, const Point&, Parameters&))
- template<typename T> KernelOperatorOnUnknowns operator*(const Unknown &un, T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&))
- template<typename T> LargeMatrix<T> operator*(const LargeMatrix<T> &mA, const LargeMatrix<T> &mB)
- template<typename T> LargeMatrix<T> operator*(const LargeMatrix<T> &mat, const T v)
- template<typename T> LargeMatrix<T> operator*(const T v, const LargeMatrix<T> &mat)
- template<typename T> LcTerm<TermMatrix> operator*(const T &t, const TermMatrix &tv)
- template<typename T> LcTerm<TermMatrix> operator*(const TermMatrix &tv, const T &t)
- template<typename T> LcTerm<TermVector> operator*(const T &t, const TermVector &tv)
- template<typename T> LcTerm<TermVector> operator*(const TermVector &tv, const T &t)
- template<typename T> LowRankMatrix<T> operator*(const LowRankMatrix<T> &L1, const T &s)
- template<typename T> LowRankMatrix<T> operator*(const T &s, const LowRankMatrix<T> &L1)
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, T (*fun)(const Point&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, T (*fun)(const Vector<Point>&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const Matrix<T> &val)
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const Vector<T> &val)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Point&, Parameters&), OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Point&, Parameters&), const Unknown &un)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Vector<Point>&, Parameters&), OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Vector<Point>&, Parameters&), const Unknown &un)
- template<typename T> OperatorOnUnknown &operator*(const Matrix<T> &val, OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(const Matrix<T> &val, const Unknown &un)
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, T (*fun)(const Point&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, T (*fun)(const Vector<Point>&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, const Matrix<T> &val)
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, const Vector<T> &val)
- template<typename T> OperatorOnUnknown &operator*(const Vector<T> &val, OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(const Vector<T> &val, const Unknown &un)
- template<typename T> TermMatrix operator*(const TermMatrix &tM, const T &t)
- template<typename T> Vector<Vector<T>> operator*(const Vector<Vector<T>> &A, const real_t &x)
- template<typename T> Vector<Vector<T>> operator*(const real_t &x, const Vector<Vector<T>> &A)
- template<typename T> std::vector<T> operator*(const LargeMatrix<T> &mat, const std::vector<T> &vec)
- template<typename T> std::vector<T> operator*(const LowRankMatrix<T> &lrm, const std::vector<T> &x)
- template<typename T> std::vector<T> operator*(const std::vector<T> &vec, const LargeMatrix<T> &mat)
- template<typename T> std::vector<T> operator*(const std::vector<T> &x, const LowRankMatrix<T> &lrm)
- template<typename T> std::vector<Vector<T>> operator*(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec)
- template<typename T> std::vector<Vector<T>> operator*(const std::vector<Vector<T>> &vec, const LargeMatrix<Matrix<T>> &mat)
- template<typename TT, typename T> LcTerm<TT> operator*(const LcTerm<TT> &lc, const T &v)
- template<typename TT, typename T> LcTerm<TT> operator*(const T &v, const LcTerm<TT> &lc)

Warning

doxygenfunction: Unable to resolve function “xlifepp::operator*” with arguments (const TermMatrix&, const T&) in doxygen xml output for project “xlifepp” from directory: ../../xlifepp/doc/xml/. Potential matches:

- BasicBilinearForm &operator*(const BasicBilinearForm&, const BasicBilinearForm&)
- BilinearForm operator*(const BilinearForm&, const BilinearForm&)
- BilinearForm operator*(const BilinearForm&, const complex_t&)
- BilinearForm operator*(const BilinearForm&, const int&)
- BilinearForm operator*(const BilinearForm&, const int_t&)
- BilinearForm operator*(const BilinearForm&, const number_t&)
- BilinearForm operator*(const BilinearForm&, const real_t&)
- BilinearForm operator*(const complex_t&, const BilinearForm&)
- BilinearForm operator*(const int&, const BilinearForm&)
- BilinearForm operator*(const int_t&, const BilinearForm&)
- BilinearForm operator*(const number_t&, const BilinearForm&)
- BilinearForm operator*(const real_t&, const BilinearForm&)
- KernelOperatorOnTermVector operator*(const Kernel &ker, const TermVector &tv)
- KernelOperatorOnTermVector operator*(const OperatorOnKernel &opk, const TermVector &tv)
- KernelOperatorOnTermVector operator*(const TermVector &tv, const Kernel &ker)
- KernelOperatorOnTermVector operator*(const TermVector &tv, const OperatorOnKernel &opker)
- KernelOperatorOnTermVectorAndUnknown operator*(const KernelOperatorOnTermVector &koptv, const OperatorOnUnknown &opv)
- KernelOperatorOnTermVectorAndUnknown operator*(const KernelOperatorOnTermVector &koptv, const Unknown &v)
- KernelOperatorOnTermVectorAndUnknown operator*(const KernelOperatorOnTermVectorAndUnknown&, const OperatorOnUnknown&)
- KernelOperatorOnTermVectorAndUnknown operator*(const OperatorOnUnknown &opv, const KernelOperatorOnTermVector &koptv)
- KernelOperatorOnTermVectorAndUnknown operator*(const OperatorOnUnknown&, const KernelOperatorOnTermVectorAndUnknown&)
- KernelOperatorOnTermVectorAndUnknown operator*(const Unknown &v, const KernelOperatorOnTermVector &koptv)
- KernelOperatorOnUnknowns operator*(const Kernel&, const OperatorOnUnknown&)
- KernelOperatorOnUnknowns operator*(const Kernel&, const Unknown&)
- KernelOperatorOnUnknowns operator*(const KernelOperatorOnUnknowns&, const OperatorOnUnknown&)
- KernelOperatorOnUnknowns operator*(const KernelOperatorOnUnknowns&, const Unknown&)
- KernelOperatorOnUnknowns operator*(const OperatorOnKernel&, const OperatorOnUnknown&)
- KernelOperatorOnUnknowns operator*(const OperatorOnUnknown&, const Kernel&)
- KernelOperatorOnUnknowns operator*(const OperatorOnUnknown&, const KernelOperatorOnUnknowns&)
- KernelOperatorOnUnknowns operator*(const OperatorOnUnknown&, const OperatorOnKernel&)
- KernelOperatorOnUnknowns operator*(const Unknown&, const Kernel&)
- KernelOperatorOnUnknowns operator*(const Unknown&, const KernelOperatorOnUnknowns&)
- LargeMatrix<Matrix<complex_t>> operator*(const LargeMatrix<Matrix<complex_t>> &mA, const LargeMatrix<Matrix<real_t>> &mB)
- LargeMatrix<Matrix<complex_t>> operator*(const LargeMatrix<Matrix<real_t>> &mA, const LargeMatrix<Matrix<complex_t>> &mB)
- LargeMatrix<complex_t> operator*(const LargeMatrix<complex_t> &mA, const LargeMatrix<real_t> &mB)
- LargeMatrix<complex_t> operator*(const LargeMatrix<complex_t> &mat, const real_t v)
- LargeMatrix<complex_t> operator*(const LargeMatrix<real_t> &mA, const LargeMatrix<complex_t> &mB)
- LargeMatrix<complex_t> operator*(const LargeMatrix<real_t> &mat, const complex_t v)
- LargeMatrix<complex_t> operator*(const complex_t v, const LargeMatrix<real_t> &mat)
- LargeMatrix<complex_t> operator*(const real_t v, const LargeMatrix<complex_t> &mat)
- LcKernelOperatorOnUnknowns operator*(const LcKernelOperatorOnUnknowns &lc, const complex_t &a)
- LcKernelOperatorOnUnknowns operator*(const LcKernelOperatorOnUnknowns &lc, const real_t &a)
- LcKernelOperatorOnUnknowns operator*(const complex_t &a, const LcKernelOperatorOnUnknowns &lc)
- LcKernelOperatorOnUnknowns operator*(const real_t &a, const LcKernelOperatorOnUnknowns &lc)
- LcOperatorOnUnknown operator*(const LcOperatorOnUnknown &lc, const complex_t &a)
- LcOperatorOnUnknown operator*(const LcOperatorOnUnknown &lc, const real_t &a)
- LcOperatorOnUnknown operator*(const complex_t &a, const LcOperatorOnUnknown &lc)
- LcOperatorOnUnknown operator*(const real_t &a, const LcOperatorOnUnknown &lc)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknown &lcopu, const LcOperatorOnUnknown &lcopv)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknown &lcopu, const OperatorOnUnknown &opv)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknown &lcopu, const Unknown &v)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknowns &lc, const complex_t &a)
- LcOperatorOnUnknowns operator*(const LcOperatorOnUnknowns &lc, const real_t &a)
- LcOperatorOnUnknowns operator*(const OperatorOnUnknown &opu, const LcOperatorOnUnknown &lcopv)
- LcOperatorOnUnknowns operator*(const Unknown &u, const LcOperatorOnUnknown &lcopv)
- LcOperatorOnUnknowns operator*(const complex_t &a, const LcOperatorOnUnknowns &lc)
- LcOperatorOnUnknowns operator*(const real_t &a, const LcOperatorOnUnknowns &lc)
- LinearForm operator*(const LinearForm&, const complex_t&)
- LinearForm operator*(const LinearForm&, const int&)
- LinearForm operator*(const LinearForm&, const int_t&)
- LinearForm operator*(const LinearForm&, const number_t&)
- LinearForm operator*(const LinearForm&, const real_t&)
- LinearForm operator*(const complex_t&, const LinearForm&)
- LinearForm operator*(const int&, const LinearForm&)
- LinearForm operator*(const int_t&, const LinearForm&)
- LinearForm operator*(const number_t&, const LinearForm&)
- LinearForm operator*(const real_t&, const LinearForm&)
- Matrix<complex_t> operator*(const Matrix<complex_t> &cA, const Matrix<real_t> &rB)
- Matrix<complex_t> operator*(const Matrix<real_t> &rA, const Matrix<complex_t> &cB)
- Matrix<complex_t> operator*(const Matrix<real_t> &rA, const complex_t &x)
- Matrix<complex_t> operator*(const complex_t &x, const Matrix<real_t> &rA)
- MatrixEntry operator*(const MatrixEntry&, const MatrixEntry&)
- OperatorOnFunction &operator*(OperatorOnFunction&, UnitaryVector)
- OperatorOnFunction &operator*(UnitaryVector n, const Matrix<complex_t> &v)
- OperatorOnFunction &operator*(UnitaryVector n, const Matrix<real_t> &v)
- OperatorOnFunction &operator*(UnitaryVector n, const complex_t &v)
- OperatorOnFunction &operator*(UnitaryVector n, const real_t &v)
- OperatorOnFunction &operator*(UnitaryVector, OperatorOnFunction&)
- OperatorOnFunction &operator*(UnitaryVector, const Function&)
- OperatorOnFunction &operator*(const Extension &e, OperatorOnFunction &opf)
- OperatorOnFunction &operator*(const Extension &e, const Function &f)
- OperatorOnFunction &operator*(const Function&, UnitaryVector)
- OperatorOnFunction &operator*(const Matrix<complex_t> &v, UnitaryVector n)
- OperatorOnFunction &operator*(const Matrix<real_t> &v, UnitaryVector n)
- OperatorOnFunction &operator*(const complex_t &v, UnitaryVector n)
- OperatorOnFunction &operator*(const real_t &v, UnitaryVector n)
- OperatorOnKernel &operator*(OperatorOnKernel&, UnitaryVector)
- OperatorOnKernel &operator*(UnitaryVector, OperatorOnKernel&)
- OperatorOnKernel &operator*(UnitaryVector, const Kernel&)
- OperatorOnKernel &operator*(const Extension &e, OperatorOnKernel &opk)
- OperatorOnKernel &operator*(const Extension &e, const Kernel &k)
- OperatorOnKernel &operator*(const Kernel&, UnitaryVector)
- OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const TermVector &tv)
- OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const complex_t &val)
- OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const real_t &val)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, UnitaryVector)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, const Function&)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, const OperatorOnFunction&)
- OperatorOnUnknown &operator*(OperatorOnUnknown&, const Value&)
- OperatorOnUnknown &operator*(UnitaryVector, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(UnitaryVector, const Unknown&)
- OperatorOnUnknown &operator*(const Function&, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(const Function&, const Unknown&)
- OperatorOnUnknown &operator*(const OperatorOnFunction&, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(const OperatorOnFunction&, const Unknown&)
- OperatorOnUnknown &operator*(const TermVector &tv, OperatorOnUnknown &opu)
- OperatorOnUnknown &operator*(const TermVector &tv, const TestFunction &un)
- OperatorOnUnknown &operator*(const TermVector &tv, const Unknown &un)
- OperatorOnUnknown &operator*(const TestFunction &un, const TermVector &tv)
- OperatorOnUnknown &operator*(const Unknown &un, const TermVector &tv)
- OperatorOnUnknown &operator*(const Unknown&, UnitaryVector)
- OperatorOnUnknown &operator*(const Unknown&, const Function&)
- OperatorOnUnknown &operator*(const Unknown&, const OperatorOnFunction&)
- OperatorOnUnknown &operator*(const Unknown&, const Value&)
- OperatorOnUnknown &operator*(const Unknown&, const complex_t&)
- OperatorOnUnknown &operator*(const Unknown&, const real_t&)
- OperatorOnUnknown &operator*(const Value&, OperatorOnUnknown&)
- OperatorOnUnknown &operator*(const Value&, const Unknown&)
- OperatorOnUnknown &operator*(const complex_t &val, OperatorOnUnknown &opu)
- OperatorOnUnknown &operator*(const complex_t&, const Unknown&)
- OperatorOnUnknown &operator*(const real_t &val, OperatorOnUnknown &opu)
- OperatorOnUnknown &operator*(const real_t&, const Unknown&)
- OperatorOnUnknowns operator*(OperatorOnUnknown&, OperatorOnUnknown&)
- OperatorOnUnknowns operator*(OperatorOnUnknown&, Unknown&)
- OperatorOnUnknowns operator*(Unknown&, OperatorOnUnknown&)
- OperatorOnUnknowns operator*(Unknown&, Unknown&)
- Parameter operator*(const Parameter &p, const complex_t &v)
- Parameter operator*(const Parameter &p, const int v)
- Parameter operator*(const Parameter &p, const int_t v)
- Parameter operator*(const Parameter &p, const number_t v)
- Parameter operator*(const Parameter &p, const real_t v)
- Parameter operator*(const Parameter &p1, const Parameter &p2)
- Parameter operator*(const complex_t &v, const Parameter &p)
- Parameter operator*(const int v, const Parameter &p)
- Parameter operator*(const int_t v, const Parameter &p)
- Parameter operator*(const number_t v, const Parameter &p)
- Parameter operator*(const real_t v, const Parameter &p)
- Point operator*(const Point&, const real_t)
- Point operator*(const real_t, const Point&)
- SuBilinearForm operator*(const SuBilinearForm&, const complex_t&)
- SuBilinearForm operator*(const complex_t&, const SuBilinearForm&)
- SuLinearForm operator*(const SuLinearForm &sulf, const complex_t &c)
- SuLinearForm operator*(const complex_t &c, const SuLinearForm &sulf)
- SuTermMatrix operator*(const SuTermMatrix&, const SuTermMatrix&)
- SuTermVector operator*(const SuTermMatrix &sutM, const SuTermVector &sutV)
- SuTermVector operator*(const SuTermVector &s1, const SuTermVector &s2)
- SuTermVector operator*(const SuTermVector &sutV, const SuTermMatrix &sutM)
- SymbolicFunction &operator*(const SymbolicFunction &f, const complex_t &c)
- SymbolicFunction &operator*(const SymbolicFunction &f, const real_t &r)
- SymbolicFunction &operator*(const SymbolicFunction &f1, const SymbolicFunction &f2)
- SymbolicFunction &operator*(const complex_t &c, const SymbolicFunction &f)
- SymbolicFunction &operator*(const real_t &r, const SymbolicFunction &f)
- SymbolicTermMatrix &operator*(LcTerm<TermMatrix> &LC, SymbolicTermMatrix &S)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S, LcTerm<TermMatrix> &LC)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S, const TermMatrix &M)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S, const complex_t &c)
- SymbolicTermMatrix &operator*(SymbolicTermMatrix &S1, SymbolicTermMatrix &S2)
- SymbolicTermMatrix &operator*(const TermMatrix &M, SymbolicTermMatrix &S)
- SymbolicTermMatrix &operator*(const complex_t &c, SymbolicTermMatrix &S)
- TermMatrix operator*(const TermMatrix&, const TermMatrix&)
- TermVector operator*(const LcTerm<TermMatrix>&, const TermVector&)
- TermVector operator*(const Projector &P, const TermVector &X)
- TermVector operator*(const SymbolicTermMatrix &S, const TermVector &X)
- TermVector operator*(const TermMatrix &tM, const LcTerm<TermVector> &lctv)
- TermVector operator*(const TermMatrix&, const TermVector&)
- TermVector operator*(const TermVector &X, const SymbolicTermMatrix &S)
- TermVector operator*(const TermVector &s1, const TermVector &s2)
- TermVector operator*(const TermVector&, const TermMatrix&)
- Transformation operator*(const Transformation &t1, const Transformation &t2)
- Vector<Matrix<complex_t>> operator*(const real_t &x, const Vector<Matrix<complex_t>> &a)
- Vector<Vector<complex_t>> operator*(const Vector<Vector<complex_t>>&, const complex_t&)
- Vector<Vector<complex_t>> operator*(const complex_t&, const Vector<Vector<complex_t>>&)
- Vector<complex_t> operator*(const Matrix<complex_t> &cA, const Vector<real_t> &rV)
- Vector<complex_t> operator*(const Matrix<real_t> &rA, const Vector<complex_t> &cV)
- Vector<complex_t> operator*(const Vector<complex_t> &cA, const real_t &x)
- Vector<complex_t> operator*(const Vector<complex_t> &cV, const Matrix<real_t> &rA)
- Vector<complex_t> operator*(const Vector<real_t> &rA, const complex_t &x)
- Vector<complex_t> operator*(const Vector<real_t> &rV, const Matrix<complex_t> &cA)
- Vector<complex_t> operator*(const complex_t &x, const Vector<real_t> &rA)
- Vector<complex_t> operator*(const real_t &x, const Vector<complex_t> &cA)
- VectorEntry operator*(const MatrixEntry &mat, const VectorEntry &vec)
- VectorEntry operator*(const VectorEntry &vec, const MatrixEntry &mat)
- complex_t operator*(const complex_t &z, const int i)
- complex_t operator*(const complex_t &z, const int_t i)
- complex_t operator*(const complex_t &z, const number_t n)
- complex_t operator*(const int i, const complex_t &z)
- complex_t operator*(const int_t i, const complex_t &z)
- complex_t operator*(const number_t n, const complex_t &z)
- real_t operator*(real_t a, const AngleUnit &u)
- std::vector<Vector<complex_t>> operator*(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec)
- std::vector<Vector<complex_t>> operator*(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec)
- std::vector<Vector<complex_t>> operator*(const std::vector<Vector<complex_t>> &vec, const LargeMatrix<Matrix<real_t>> &mat)
- std::vector<Vector<complex_t>> operator*(const std::vector<Vector<real_t>> &vec, const LargeMatrix<Matrix<complex_t>> &mat)
- std::vector<complex_t> operator*(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec)
- std::vector<complex_t> operator*(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec)
- std::vector<complex_t> operator*(const std::vector<complex_t> &vec, const LargeMatrix<real_t> &mat)
- std::vector<complex_t> operator*(const std::vector<real_t> &vec, const LargeMatrix<complex_t> &mat)
- template<typename K, typename KK> Matrix<K> operator*(const KK &x, const Matrix<K> &a)
- template<typename K, typename KK> SparseMatrix<K> operator*(const KK &x, const SparseMatrix<K> &a)
- template<typename K, typename KK> SparseMatrix<K> operator*(const SparseMatrix<K> &a, const KK &x)
- template<typename K, typename KK> VectorEigenDense<K> operator*(const KK &k, const VectorEigenDense<K> &vec)
- template<typename K, typename KK> VectorEigenDense<K> operator*(const VectorEigenDense<K> &vec, const KK &k)
- template<typename K, typename V> Vector<K> operator*(const Matrix<K> &m, const Vector<V> &v)
- template<typename K, typename V> Vector<K> operator*(const SparseMatrix<K> &m, const std::vector<V> &v)
- template<typename K, typename V> Vector<K> operator*(const Vector<V> &v, const Matrix<K> &m)
- template<typename K, typename V> Vector<K> operator*(const std::vector<V> &v, const SparseMatrix<K> &m)
- template<typename K> Matrix<K> operator*(const Matrix<K> &a, const K &x)
- template<typename K> Matrix<K> operator*(const Matrix<K> &a, const Matrix<K> &b)
- template<typename K> MonomialT<K> operator*(const MonomialT<K> &m1, const MonomialT<K> &m2)
- template<typename K> PolynomialBasisT<K> operator*(const PolynomialBasisT<K> &p, const PolynomialBasisT<K> &q)
- template<typename K> PolynomialT<K> operator*(const K &k, const MonomialT<K> &m)
- template<typename K> PolynomialT<K> operator*(const K &k, const PolynomialT<K> &p)
- template<typename K> PolynomialT<K> operator*(const MonomialT<K> &m, const K &k)
- template<typename K> PolynomialT<K> operator*(const MonomialT<K> &m, const PolynomialT<K> &p)
- template<typename K> PolynomialT<K> operator*(const PolynomialT<K> &p, const K &k)
- template<typename K> PolynomialT<K> operator*(const PolynomialT<K> &p, const MonomialT<K> &m)
- template<typename K> PolynomialT<K> operator*(const PolynomialT<K> &p1, const PolynomialT<K> &p2)
- template<typename K> PolynomialsBasisT<K> operator*(const Matrix<K> &mat, const PolynomialsBasisT<K> &ps)
- template<typename K> PolynomialsBasisT<K> operator*(const PolynomialBasisT<K> &pb, const std::vector<MonomialT<K>> &vp)
- template<typename K> Vector<K> operator*(const K &x, const Vector<K> &a)
- template<typename K> Vector<K> operator*(const Vector<K> &a, const K &x)
- template<typename K> Vector<K> operator*(const Vector<K> &a, const Vector<K> &b)
- template<typename K> Vector<Matrix<K>> operator*(const K &x, const Vector<Matrix<K>> &a)
- template<typename K> std::vector<PolynomialT<K>> operator*(const Matrix<K> &mat, const std::vector<PolynomialT<K>> &ps)
- template<typename T, typename I> Vector<T> operator*(const HMatrix<T, I> &h, const Vector<T> &x)
- template<typename T> KernelOperatorOnUnknowns operator*(T (*fun)(const Point&, const Point&, Parameters&), const Unknown &un)
- template<typename T> KernelOperatorOnUnknowns operator*(T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&), const Unknown &un)
- template<typename T> KernelOperatorOnUnknowns operator*(const Unknown &un, T (*fun)(const Point&, const Point&, Parameters&))
- template<typename T> KernelOperatorOnUnknowns operator*(const Unknown &un, T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&))
- template<typename T> LargeMatrix<T> operator*(const LargeMatrix<T> &mA, const LargeMatrix<T> &mB)
- template<typename T> LargeMatrix<T> operator*(const LargeMatrix<T> &mat, const T v)
- template<typename T> LargeMatrix<T> operator*(const T v, const LargeMatrix<T> &mat)
- template<typename T> LcTerm<TermMatrix> operator*(const T &t, const TermMatrix &tv)
- template<typename T> LcTerm<TermMatrix> operator*(const TermMatrix &tv, const T &t)
- template<typename T> LcTerm<TermVector> operator*(const T &t, const TermVector &tv)
- template<typename T> LcTerm<TermVector> operator*(const TermVector &tv, const T &t)
- template<typename T> LowRankMatrix<T> operator*(const LowRankMatrix<T> &L1, const T &s)
- template<typename T> LowRankMatrix<T> operator*(const T &s, const LowRankMatrix<T> &L1)
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, T (*fun)(const Point&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, T (*fun)(const Vector<Point>&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const Matrix<T> &val)
- template<typename T> OperatorOnUnknown &operator*(OperatorOnUnknown &opu, const Vector<T> &val)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Point&, Parameters&), OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Point&, Parameters&), const Unknown &un)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Vector<Point>&, Parameters&), OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(T (*fun)(const Vector<Point>&, Parameters&), const Unknown &un)
- template<typename T> OperatorOnUnknown &operator*(const Matrix<T> &val, OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(const Matrix<T> &val, const Unknown &un)
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, T (*fun)(const Point&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, T (*fun)(const Vector<Point>&, Parameters&))
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, const Matrix<T> &val)
- template<typename T> OperatorOnUnknown &operator*(const Unknown &un, const Vector<T> &val)
- template<typename T> OperatorOnUnknown &operator*(const Vector<T> &val, OperatorOnUnknown &opu)
- template<typename T> OperatorOnUnknown &operator*(const Vector<T> &val, const Unknown &un)
- template<typename T> TermMatrix operator*(const TermMatrix &tM, const T &t)
- template<typename T> Vector<Vector<T>> operator*(const Vector<Vector<T>> &A, const real_t &x)
- template<typename T> Vector<Vector<T>> operator*(const real_t &x, const Vector<Vector<T>> &A)
- template<typename T> std::vector<T> operator*(const LargeMatrix<T> &mat, const std::vector<T> &vec)
- template<typename T> std::vector<T> operator*(const LowRankMatrix<T> &lrm, const std::vector<T> &x)
- template<typename T> std::vector<T> operator*(const std::vector<T> &vec, const LargeMatrix<T> &mat)
- template<typename T> std::vector<T> operator*(const std::vector<T> &x, const LowRankMatrix<T> &lrm)
- template<typename T> std::vector<Vector<T>> operator*(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec)
- template<typename T> std::vector<Vector<T>> operator*(const std::vector<Vector<T>> &vec, const LargeMatrix<Matrix<T>> &mat)
- template<typename TT, typename T> LcTerm<TT> operator*(const LcTerm<TT> &lc, const T &v)
- template<typename TT, typename T> LcTerm<TT> operator*(const T &v, const LcTerm<TT> &lc)

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

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)

operator-

BilinearForm xlifepp::operator-(const BilinearForm&)

opposite of a bilinear form

BilinearForm xlifepp::operator-(const BilinearForm&, const BilinearForm&)

difference of bilinear forms

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

Parameter xlifepp::operator-(const complex_t &v, const Parameter &p)

difference complex and parameter

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

complex value - real matrix

complex x - real matrix A

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

subtract real vector from complex scalar

subtract “complex 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)

GeomDomain &xlifepp::operator-(const GeomDomain &dom1, const GeomDomain &dom2)

internal tool used by MeshDomain::fictitiousDomain

create the domain made of dom1 elements that are not in dom2

Geometry xlifepp::operator-(const Geometry &g1, const Geometry &g2)

g2 hole of g1 (general case)

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

Parameter xlifepp::operator-(const int v, const Parameter &p)

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

difference int_t and parameter

template<typename K>
Vector<K> xlifepp::operator-(const K &x, const Vector<K> &a)

subtract vector from scalar “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 &lc)

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

LcKernelOperatorOnUnknowns xlifepp::operator-(const LcKernelOperatorOnUnknowns &lc1, const LcKernelOperatorOnUnknowns &lc2)

LcOperatorOnUnknown xlifepp::operator-(const LcOperatorOnUnknown &lc)

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

substraction of a TermMatrix of 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&)

opposite of a linear form

LinearForm xlifepp::operator-(const LinearForm&, const LinearForm&)

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

real matrix - 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)

matrix A - matrix B

template<typename K>
Matrix<K> xlifepp::operator-(const Matrix<K> &m)

unary operator- (negation operator)

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

real matrix - complex value

real matrix A - complex x

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

complex matrix - real matrix

real matrix A - complex matrix B

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

Parameter xlifepp::operator-(const number_t v, const Parameter &p)

difference 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 &opus, const LcOperatorOnUnknowns &lc)

LcOperatorOnUnknowns xlifepp::operator-(const OperatorOnUnknowns &opus1, const OperatorOnUnknowns &opus2)

Parameter xlifepp::operator-(const Parameter &p)

Parameter xlifepp::operator-(const Parameter &p, const complex_t &v)

difference parameter and complex

Parameter xlifepp::operator-(const Parameter &p, const int v)

difference parameter and int

Parameter xlifepp::operator-(const Parameter &p, const int_t v)

difference parameter and int_t

Parameter xlifepp::operator-(const Parameter &p, const number_t v)

difference parameter and number_t

Parameter xlifepp::operator-(const Parameter &p, const real_t v)

difference parameter and real

Parameter xlifepp::operator-(const Parameter &p1, const Parameter &p2)

difference of 2 parameters

Point xlifepp::operator-(const Point&)

opposite point

Point xlifepp::operator-(const Point&, const Point&)

difference of two points

Point xlifepp::operator-(const Point&, const real_t)

difference of two points

template<typename K>
PolynomialT<K> xlifepp::operator-(const PolynomialT<K> &m)

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)

substract complex vector from real scalar

subtract real scalar to complex vector

Parameter xlifepp::operator-(const real_t v, const Parameter &p)

difference real and parameter

Point xlifepp::operator-(const real_t, const Point&)

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

matrix A - matrix B

template<typename K>
SparseMatrix<K> xlifepp::operator-(const SparseMatrix<K> &m)

unary operator- (negation operator)

SuBilinearForm xlifepp::operator-(const SuBilinearForm&)

opposite of bilinear form

SuBilinearForm xlifepp::operator-(const SuBilinearForm&, const SuBilinearForm&)

difference of bilinear forms

SuLinearForm xlifepp::operator-(const SuLinearForm &sulf)

opposite of linear form

SuLinearForm xlifepp::operator-(const SuLinearForm &sulf1, const SuLinearForm &sulf2)

difference of linear forms

inline SuTermVector xlifepp::operator-(const SuTermVector &s)

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

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)

LcTerm<TermMatrix> xlifepp::operator-(const TermMatrix&)

unary operator- (returns a LcTerm)

LcTerm<TermMatrix> xlifepp::operator-(const TermMatrix&, const LcTerm<TermMatrix>&)

substraction of a LcTerm from a TermMatrix

LcTerm<TermMatrix> xlifepp::operator-(const TermMatrix&, const TermMatrix&)

substraction of TermMatrix of a TermMatrix

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

LcTerm<TermVector> xlifepp::operator-(const TermVector &tv)

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

Value xlifepp::operator-(const Value &v)

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

substract real scalar from complex vector

subtract real scalar to complex vector

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

vector subtraction A - B

vector subtraction “complex A - real B”

template<typename K>
Vector<K> xlifepp::operator-(const Vector<K> &a)

unary - (return opposite vector)

template<typename K>
Vector<K> xlifepp::operator-(const Vector<K> &a, const K &x)

subtract vector from scalar “A-x”

template<typename K>
Vector<K> xlifepp::operator-(const Vector<K> &a, const Vector<K> &b)

vector subtraction “A-B”

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

subtract scalar from vector A - x

subtract scalar to vector “ A - complex x”

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

vector subtraction A - B

vector subtraction “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)

operator/

BilinearForm xlifepp::operator/(const BilinearForm&, const complex_t&)

division by a complex scalar

BilinearForm xlifepp::operator/(const BilinearForm&, const int&)

division by an integer scalar

BilinearForm xlifepp::operator/(const BilinearForm&, const int_t&)

division by an integer scalar

BilinearForm xlifepp::operator/(const BilinearForm&, const number_t&)

division by an integer scalar

BilinearForm xlifepp::operator/(const BilinearForm&, const real_t&)

division by a real scalar

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

Parameter xlifepp::operator/(const complex_t &v, const Parameter &p)

division complex and parameter

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)

Parameter xlifepp::operator/(const int v, const Parameter &p)

division int and parameter

Parameter xlifepp::operator/(const int_t v, const Parameter &p)

division int_t and parameter

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 LcOperatorOnUnknowns &lc, const complex_t &a)

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

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

LinearForm xlifepp::operator/(const LinearForm&, const complex_t&)

division by a scalar

LinearForm xlifepp::operator/(const LinearForm&, const int&)

division by a scalar

LinearForm xlifepp::operator/(const LinearForm&, const int_t&)

division by a scalar

LinearForm xlifepp::operator/(const LinearForm&, const number_t&)

division by a scalar

LinearForm xlifepp::operator/(const LinearForm&, const real_t&)

division by a scalar

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

template<typename K, typename KK>
Matrix<K> xlifepp::operator/(const Matrix<K> &a, const KK &x)

matrix A / scalar x

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

divide real matrix by a complex value

real matrix A / complex x

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

Parameter xlifepp::operator/(const number_t v, const Parameter &p)

division number_t and parameter

Parameter xlifepp::operator/(const Parameter &p, const complex_t &v)

division parameter and complex

Parameter xlifepp::operator/(const Parameter &p, const int v)

division parameter and int_t

Parameter xlifepp::operator/(const Parameter &p, const int_t v)

division parameter and int

Parameter xlifepp::operator/(const Parameter &p, const number_t v)

division parameter and number_t

Parameter xlifepp::operator/(const Parameter &p, const real_t v)

division parameter and real

Parameter xlifepp::operator/(const Parameter &p1, const Parameter &p2)

division of 2 parameters

Point xlifepp::operator/(const Point&, const real_t)

scale a point

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

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

Parameter xlifepp::operator/(const real_t v, const Parameter &p)

division real and parameter

template<typename K, typename KK>
SparseMatrix<K> xlifepp::operator/(const SparseMatrix<K> &a, const KK &x)

matrix A / scalar x

SuBilinearForm xlifepp::operator/(const SuBilinearForm&, const complex_t&)

divide by a scalar

SuLinearForm xlifepp::operator/(const SuLinearForm &sulf, const complex_t &c)

division by a scalar

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

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)

template<typename T>
LcTerm<TermMatrix> xlifepp::operator/(const TermMatrix &tv, const T &t)

division of TermMatrix by a real or a complex (template T)

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

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

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

divide complex vector by real scalar

divide complex vector by real scalar “A / x”

template<typename K>
Vector<K> xlifepp::operator/(const Vector<K> &a, const K &x)

divide vector by a scalar “ A / x”

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

divide real vector by complex scalar

divide real vector by complex scalar “A / x”

Vector<Vector<complex_t>> xlifepp::operator/(const Vector<Vector<complex_t>>&, const complex_t&)

divide 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 T>
inline VectorEntry xlifepp::operator/(const VectorEntry &v, const T &a)

operation V/=a

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

operator<

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

bool xlifepp::operator<(const Dof&, const Dof&)

order between dofs

bool xlifepp::operator<(const DofComponent&, const DofComponent&)

less than

inline bool xlifepp::operator<(const DofKey &k1, const DofKey &k2)

bool xlifepp::operator<(const DomUnkDop&, const DomUnkDop&)

less than

bool xlifepp::operator<(const GeomElement&, const GeomElement&)

operator < to sort elements

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

bool xlifepp::operator<(const Point&, const Point&)

leather than between two points

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

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator<(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, U *rhs)

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)

template<class K>
bool xlifepp::operator<(const Triplet<K> &t1, const Triplet<K> &t2)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator<(U *lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T>
inline ComparisonFunction<T> xlifepp::operator<(VarComparison, const T &a)

operator<<

template<typename T>
Collection<T> &xlifepp::operator<<(Collection<T> &ns, const T &n)

insertion utility

template<typename T>
PCollection<T> &xlifepp::operator<<(PCollection<T> &ts, const T &t)

insertion operator

std::ostream &xlifepp::operator<<(std::ostream&, const BilinearForm&)

output BilinearForm

std::ostream &xlifepp::operator<<(std::ostream&, const CompositeDomain&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Constraints&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const CrackData&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const DifferentialOperator&)

print utility

std::ostream &xlifepp::operator<<(std::ostream&, const Dof&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const DofComponent&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const DomainInfo&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const EigenElements&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Element&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const EssentialCondition&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const EssentialConditions&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const FeSubSpace&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Function&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const GeomDomain&)

print geomdomain

std::ostream &xlifepp::operator<<(std::ostream&, const GeomElement&)

outputs geomelement characteristics

std::ostream &xlifepp::operator<<(std::ostream&, const Geometry&)

output Geometry

std::ostream &xlifepp::operator<<(std::ostream&, const GeomMapData&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const IntegrationMethod&)

output IntegrationMethod on stream

std::ostream &xlifepp::operator<<(std::ostream&, const Interpolation&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Kernel&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const KernelOperatorOnUnknowns&)

outputs OperatorOnUnknown attributes

std::ostream &xlifepp::operator<<(std::ostream&, const LcKernelOperatorOnUnknowns&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const LcOperatorOnUnknown&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const LcOperatorOnUnknowns&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const LinearForm&)

output LinearForm

std::ostream &xlifepp::operator<<(std::ostream&, const MatrixEntry&)

print on ostream

std::ostream &xlifepp::operator<<(std::ostream&, const MatrixStorage&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Mesh&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const MeshDomain&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const MeshElement&)

prints characteristics and point numbers

std::ostream &xlifepp::operator<<(std::ostream&, const Operand&)

outputs Operand attributes

std::ostream &xlifepp::operator<<(std::ostream&, const OperatorOnUnknown&)

outputs OperatorOnUnknown attributes

std::ostream &xlifepp::operator<<(std::ostream&, const OperatorOnUnknowns&)

outputs OperatorOnUnknown attributes

std::ostream &xlifepp::operator<<(std::ostream&, const Parameter&)

output operator

std::ostream &xlifepp::operator<<(std::ostream&, const Parameters&)

flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream&, const PhysicalData&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Point&)

ostream insert

std::ostream &xlifepp::operator<<(std::ostream&, const PointsDomain&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Projector&)

output on stream

std::ostream &xlifepp::operator<<(std::ostream&, const Quadrature&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const QuadratureIM&)

output on stream

std::ostream &xlifepp::operator<<(std::ostream&, const QuadratureRule&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const RefElement&)

output operator

std::ostream &xlifepp::operator<<(std::ostream&, const SetOfConstraints&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const SpectralBasis&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const SuBilinearForm&)

output SuBilinearForm

std::ostream &xlifepp::operator<<(std::ostream&, const SubSpace&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Term&)

print operator

std::ostream &xlifepp::operator<<(std::ostream&, const Unknown&)

print an unknown

std::ostream &xlifepp::operator<<(std::ostream&, const Value&)

outputs Value in a output stream

std::ostream &xlifepp::operator<<(std::ostream&, const VectorEntry&)

output VectorEntry on stream

std::ostream &xlifepp::operator<<(std::ostream &os, const BoundingBox &bb)

output BoundingBox

inline std::ostream &xlifepp::operator<<(std::ostream &os, const Geodesic &g)

std::ostream &xlifepp::operator<<(std::ostream &os, const GeomRefElement &obj)

prints GeomRefElement object to ostream

print operator

std::ostream &xlifepp::operator<<(std::ostream &os, const GeoNumPair &gp)

outputs GeoNumPair characteristics

template<typename X, typename J>
std::ostream &xlifepp::operator<<(std::ostream &os, const HMatrix<X, J> &hm)

template<typename X, typename J>
std::ostream &xlifepp::operator<<(std::ostream &os, const HMatrixNode<X, J> &hm)

template<class S>
std::ostream &xlifepp::operator<<(std::ostream &os, const KdNode<S> &node)

print operator

template<class S>
std::ostream &xlifepp::operator<<(std::ostream &os, const KdTree<S> &kd)

print operator

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &os, const LargeMatrix<T> &mat)

output stream operator

std::ostream &xlifepp::operator<<(std::ostream &os, const Matrix<complex_t> &m)

complex matrix flux insertion (write)

flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream &os, const Matrix<real_t> &m)

real matrix flux insertion (write)

flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream &os, const MatrixEigenDense<complex_t> &m)

complex matrix flux insertion (write)

flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream &os, const MatrixEigenDense<real_t> &m)

real matrix flux insertion (write)

flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream &os, const MinimalBox &mb)

output MinimalBox

template<class S>
std::ostream &xlifepp::operator<<(std::ostream &os, const Node<S> &node)

print operator

std::ostream &xlifepp::operator<<(std::ostream &os, const OperatorOnFunction &opf)

std::ostream &xlifepp::operator<<(std::ostream &os, const OperatorOnKernel &opk)

inline std::ostream &xlifepp::operator<<(std::ostream &os, const ParameterKey &pk)

std::ostream &xlifepp::operator<<(std::ostream &os, const RealPair &rp)

output pair of reals

std::ostream &xlifepp::operator<<(std::ostream &os, const RefDof &obj)

print Reference D.o.F data

print operator

std::ostream &xlifepp::operator<<(std::ostream &os, const ShapeValues &obj)

print shape functions and derivatives to output file stream

print operator

inline std::ostream &xlifepp::operator<<(std::ostream &os, const SpaceMap &sm)

std::ostream &xlifepp::operator<<(std::ostream &os, const std::set<ParameterKey> &pks)

template<typename U>
std::ostream &xlifepp::operator<<(std::ostream &os, const std::vector<U> &v)

std::ostream &xlifepp::operator<<(std::ostream &os, const SuLinearForm &sulf)

output SuLinearForm

std::ostream &xlifepp::operator<<(std::ostream &os, const SuTermVectors &tvs)

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &os, const Tabular<T> &t)

general vector flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream &os, const TermVectors &tvs)

std::ostream &xlifepp::operator<<(std::ostream &os, const Transformation &t)

return the scale factor (=1.

output Transformation

if no homothety)

template<typename K>
std::ostream &xlifepp::operator<<(std::ostream &os, const Vector<K> &v)

general vector flux insertion (write)

std::ostream &xlifepp::operator<<(std::ostream &out, const AccessType &at)

std::ostream &xlifepp::operator<<(std::ostream &out, const AdjacentStatus &as)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const AlgebraicOperator &ao)

print operator for enum associated to a dictionary

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const ApproximateMatrix<T> &am)

std::ostream &xlifepp::operator<<(std::ostream &out, const BCsub &bcs)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const BezierSpline &sp)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const BSpline &sp)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const C2Spline &sp)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const CatmullRomSpline &sp)

std::ostream &xlifepp::operator<<(std::ostream &out, const ClusteringMethod &cm)

print operator for enum associated to a dictionary

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const ClusterNode<T> &cn)

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const ClusterTree<T> &ct)

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const Collection<T> &ns)

print utility

std::ostream &xlifepp::operator<<(std::ostream &out, const ComputationType &ct)

std::ostream &xlifepp::operator<<(std::ostream &out, const ContinuityOrder &co)

std::ostream &xlifepp::operator<<(std::ostream &out, const DiffOpType &dot)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const DofKey &dk)

std::ostream &xlifepp::operator<<(std::ostream &out, const DofLocalization &dl)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const DofType &dt)

std::ostream &xlifepp::operator<<(std::ostream &out, const DomainType &dt)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const EcType &et)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const EigenSolverType &est)

std::ostream &xlifepp::operator<<(std::ostream &out, const FactorizationType &ft)

std::ostream &xlifepp::operator<<(std::ostream &out, const FEMapType &femt)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const FESubType &fest)

std::ostream &xlifepp::operator<<(std::ostream &out, const FEType &fet)

std::ostream &xlifepp::operator<<(std::ostream &out, const FuncFormType &fft)

std::ostream &xlifepp::operator<<(std::ostream &out, const FunctType &ft)

std::ostream &xlifepp::operator<<(std::ostream &out, const HMApproximationMethod &hmam)

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const HMatrixEntry<T> &hme)

std::ostream &xlifepp::operator<<(std::ostream &out, const IEcomputationParameters &iep)

std::ostream &xlifepp::operator<<(std::ostream &out, const IntegrationMethodType &imt)

std::ostream &xlifepp::operator<<(std::ostream &out, const InterpolationType &it)

std::ostream &xlifepp::operator<<(std::ostream &out, const IOFormat &iof)

std::ostream &xlifepp::operator<<(std::ostream &out, const IterativeSolverType &ist)

std::ostream &xlifepp::operator<<(std::ostream &out, const Language &l)

template<typename TT>
std::ostream &xlifepp::operator<<(std::ostream &out, const LcTerm<TT> &lc)

print operator

std::ostream &xlifepp::operator<<(std::ostream &out, const LinearFormType &lft)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const Malyuzhinets &mal)

std::ostream &xlifepp::operator<<(std::ostream &out, const MemoryUnit &mu)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const MsgType &mt)

print operator for enum associated to a dictionary

inline std::ostream &xlifepp::operator<<(std::ostream &out, const Nurbs &sp)

std::ostream &xlifepp::operator<<(std::ostream &out, const OCShapeType &ocst)

std::ostream &xlifepp::operator<<(std::ostream &out, const OrientationType &ot)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const Parametrization &par)

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const PCollection<T> &ts)

print utility

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const PCollectionItem<T> &item)

output PCollectionItem on stream

std::ostream &xlifepp::operator<<(std::ostream &out, const ProjectionType &pt)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const ProjectorType &pt)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const QuadRule &qr)

std::ostream &xlifepp::operator<<(std::ostream &out, const ReductionMethodType &rmt)

std::ostream &xlifepp::operator<<(std::ostream &out, const SetOperationType &sot)

print operator for enum associated to a dictionary

std::ostream &xlifepp::operator<<(std::ostream &out, const ShapesType &sh)

std::ostream &xlifepp::operator<<(std::ostream &out, const ShapeType &sh)

std::ostream &xlifepp::operator<<(std::ostream &out, const SobolevType &st)

std::ostream &xlifepp::operator<<(std::ostream &out, const Space &sp)

output space characteristics

std::ostream &xlifepp::operator<<(std::ostream &out, const SpaceType &st)

std::ostream &xlifepp::operator<<(std::ostream &out, const SpecialMatrix &sm)

print operator for enum associated to a dictionary

inline std::ostream &xlifepp::operator<<(std::ostream &out, const Spline &sp)

std::ostream &xlifepp::operator<<(std::ostream &out, const SplineBC &sbc)

std::ostream &xlifepp::operator<<(std::ostream &out, const SplineParametrization &sp)

std::ostream &xlifepp::operator<<(std::ostream &out, const SplineSubtype &sst)

std::ostream &xlifepp::operator<<(std::ostream &out, const SplineType &st)

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const std::list<T> &l)

print a list

template<typename K, typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const std::map<K, T> &m)

print a map

template<typename K, typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const std::multimap<K, T> &m)

print a multimap

template<typename U, typename V>
std::ostream &xlifepp::operator<<(std::ostream &out, const std::pair<U, std::vector<V>> &p)

print a pair with value being a std::vector

template<typename U, typename V>
std::ostream &xlifepp::operator<<(std::ostream &out, const std::pair<U, V> &p)

print a pair

template<typename T>
std::ostream &xlifepp::operator<<(std::ostream &out, const std::set<T> &s)

print a set

std::ostream &xlifepp::operator<<(std::ostream &out, const StorageBuildType &sbt)

std::ostream &xlifepp::operator<<(std::ostream &out, const StorageType &st)

std::ostream &xlifepp::operator<<(std::ostream &out, const StrucType &st)

std::ostream &xlifepp::operator<<(std::ostream &out, const SupportType &st)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const SymbolicFunction &fn)

std::ostream &xlifepp::operator<<(std::ostream &out, const SymType &st)

std::ostream &xlifepp::operator<<(std::ostream &out, const TermType &tt)

std::ostream &xlifepp::operator<<(std::ostream &out, const TermVector &t)

inline std::ostream &xlifepp::operator<<(std::ostream &out, const Timer &T)

std::ostream &xlifepp::operator<<(std::ostream &out, const TransformType &tt)

template<class K>
std::ostream &xlifepp::operator<<(std::ostream &out, const Triplet<K> &t)

std::ostream &xlifepp::operator<<(std::ostream &out, const UnitaryVector &uv)

std::ostream &xlifepp::operator<<(std::ostream &out, const UnknownType &ut)

std::ostream &xlifepp::operator<<(std::ostream &out, const ValueType &vt)

Trace &xlifepp::operator<<(Trace&, const string_t &s)

print operator

operator<=

inline SymbolicFunction &xlifepp::operator<=(const complex_t &c, const SymbolicFunction &f)

bool xlifepp::operator<=(const DomUnkDop&, const DomUnkDop&)

less than or equal

bool xlifepp::operator<=(const Point&, const Point&)

leather than or equal (deduced from <)

inline SymbolicFunction &xlifepp::operator<=(const real_t &r, const SymbolicFunction &f)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator<=(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, U *rhs)

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)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator<=(U *lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T>
inline ComparisonFunction<T> xlifepp::operator<=(VarComparison, const T &a)

operator==

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

inline bool xlifepp::operator==(const DifferentialOperator &d1, const DifferentialOperator &d2)

bool xlifepp::operator==(const Dof&, const Dof&)

equality between dofs

bool xlifepp::operator==(const DofComponent&, const DofComponent&)

equality

bool xlifepp::operator==(const DomUnkDop&, const DomUnkDop&)

equality

bool xlifepp::operator==(const Function&, const Function&)

compare functions (same fun and params pointers)

bool xlifepp::operator==(const GeomElement&, const GeomElement&)

overload operator == to sort elements

template<typename K>
bool xlifepp::operator==(const Matrix<K> &a, const Matrix<K> &b)

matrix comparison (element by element)

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

bool xlifepp::operator==(const Operand&, const Operand&)

compare Operands

bool xlifepp::operator==(const OperatorOnFunction&, const OperatorOnFunction&)

same operator on function

bool xlifepp::operator==(const OperatorOnKernel&, const OperatorOnKernel&)

same operator on kernel

bool xlifepp::operator==(const OperatorOnUnknown&, const OperatorOnUnknown&)

compare OperatorOnUnknown (same unknowns, same diff operators, same functions …)

bool xlifepp::operator==(const Point&, const Point&)

equality of two points

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

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP>
inline bool xlifepp::operator==(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, SmartPointerNullType rhs)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator==(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, U *rhs)

template<typename K>
bool xlifepp::operator==(const SparseMatrix<K> &a, const SparseMatrix<K> &b)

matrix comparison (element by element)

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)

template<class K>
bool xlifepp::operator==(const Triplet<K> &t1, const Triplet<K> &t2)

bool xlifepp::operator==(const Value&, const Value&)

compare values

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP>
inline bool xlifepp::operator==(SmartPointerNullType lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator==(U *lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T>
inline ComparisonFunction<T> xlifepp::operator==(VarComparison, const T &a)

operator>

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

bool xlifepp::operator>(const DomUnkDop&, const DomUnkDop&)

greater than

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

bool xlifepp::operator>(const Point&, const Point&)

greater between two points (deduced from <)

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

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator>(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, U *rhs)

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)

template<class K>
bool xlifepp::operator>(const Triplet<K> &t1, const Triplet<K> &t2)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator>(U *lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T>
inline ComparisonFunction<T> xlifepp::operator>(VarComparison, const T &a)

operator>=

inline SymbolicFunction &xlifepp::operator>=(const complex_t &c, const SymbolicFunction &f)

bool xlifepp::operator>=(const DomUnkDop&, const DomUnkDop&)

greater than or equal

bool xlifepp::operator>=(const Point&, const Point&)

greater between or equal (deduced from <)

inline SymbolicFunction &xlifepp::operator>=(const real_t &r, const SymbolicFunction &f)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator>=(const SmartPtr<T, OP, CP, KP, SP, CNP> &lhs, U *rhs)

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)

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP, typename U>
inline bool xlifepp::operator>=(U *lhs, const SmartPtr<T, OP, CP, KP, SP, CNP> &rhs)

template<typename T>
inline ComparisonFunction<T> xlifepp::operator>=(VarComparison, const T &a)

operator>>

std::istream &xlifepp::operator>>(std::istream&, Parameter&)

insertion operator

operator^

OperatorOnUnknown &xlifepp::operator^(const complex_t&, const Unknown&)

c^u

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

OperatorOnUnknown &xlifepp::operator^(const Function&, const Unknown&)

F^u.

OperatorOnUnknown &xlifepp::operator^(const Function&, OperatorOnUnknown&)

cross product syntax F^Op(u)

KernelOperatorOnUnknowns xlifepp::operator^(const Kernel&, const OperatorOnUnknown&)

ker ^ opv

KernelOperatorOnUnknowns xlifepp::operator^(const Kernel&, const Unknown&)

ker ^ v

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

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)

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)

OperatorOnUnknown &xlifepp::operator^(const OperatorOnFunction&, const Unknown&)

op(F)^u

OperatorOnUnknown &xlifepp::operator^(const OperatorOnFunction&, OperatorOnUnknown&)

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

OperatorOnUnknown &xlifepp::operator^(const real_t&, const Unknown&)

r^u

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

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

template<typename T>
std::vector<T> xlifepp::operator^(const std::vector<T> &v1, const std::vector<T> &v2)

inline SuTermVector xlifepp::operator^(const SuTermVector &s, const real_t &p)

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

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

inline TermVector xlifepp::operator^(const TermVector &s, const real_t &p)

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

tv ^ ker

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

tv ^ opker

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

OperatorOnUnknown &xlifepp::operator^(const TestFunction &un, const TermVector &tv)

u^tv

inline UnitaryVector xlifepp::operator^(const UnitaryVector &n1, const UnitaryVector &n2)

cross product of unitary vector (_nx^_ny) -> _nxcrossny

OperatorOnUnknown &xlifepp::operator^(const Unknown&, const complex_t&)

u^c

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 -ncross(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&)

cross product syntax V^Op(u)

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)

OperatorOnUnknown &xlifepp::operator^(OperatorOnUnknown&, const Function&)

cross product syntax Op(u)^F

OperatorOnUnknown &xlifepp::operator^(OperatorOnUnknown&, const OperatorOnFunction&)

cross product syntax Op(u)^op(F)

OperatorOnUnknown &xlifepp::operator^(OperatorOnUnknown&, const Value&)

cross product syntax Op(u)^V

OperatorOnUnknowns xlifepp::operator^(OperatorOnUnknown&, OperatorOnUnknown&)

opu ^ opv

OperatorOnUnknown &xlifepp::operator^(OperatorOnUnknown&, UnitaryVector)

-n^(n^u) or -n^curl(u) same as -ncrossncross(u) or -ncrosscurl(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^v

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)

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, const Function&)

n^f same as ncross(f)

OperatorOnKernel &xlifepp::operator^(UnitaryVector, const Kernel&)

n^ker same as ncross(ker)

OperatorOnUnknown &xlifepp::operator^(UnitaryVector, const Unknown&)

n^u same as ncross(u)

OperatorOnFunction &xlifepp::operator^(UnitaryVector, OperatorOnFunction&)

n^opf

OperatorOnKernel &xlifepp::operator^(UnitaryVector, OperatorOnKernel&)

n^opker

OperatorOnUnknown &xlifepp::operator^(UnitaryVector, OperatorOnUnknown&)

n^(n^u) or n^curl(u) same as ncrossncross(u) or ncrosscurl(u)

OperatorOnUnknowns xlifepp::operator^(Unknown&, OperatorOnUnknown&)

u ^ opv

OperatorOnUnknowns xlifepp::operator^(Unknown&, Unknown&)

u ^ v

operator|

OperatorOnUnknown &xlifepp::operator|(const complex_t&, const Unknown&)

c|u

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

OperatorOnUnknown &xlifepp::operator|(const Function&, const Unknown&)

F|u.

OperatorOnUnknown &xlifepp::operator|(const Function&, OperatorOnUnknown&)

innerproduct syntax F|Op(u)

OperatorOnFunction &xlifepp::operator|(const Function&, UnitaryVector)

f|n same as ndot(f)

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 ndot(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

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)

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)

OperatorOnUnknown &xlifepp::operator|(const OperatorOnFunction&, const Unknown&)

op(F)|u

OperatorOnUnknown &xlifepp::operator|(const OperatorOnFunction&, OperatorOnUnknown&)

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

OperatorOnUnknown &xlifepp::operator|(const real_t&, const Unknown&)

r|u

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

TermVector xlifepp::operator|(const TermVector&, const GeomDomain&)

restrict TermVector to a GeomDomain

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

tv | ker

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

tv | opker

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

complex_t xlifepp::operator|(const TermVector &tv1, const TermVector &tv2)

main operator for inner or hermitian products

OperatorOnUnknown &xlifepp::operator|(const TestFunction &un, const TermVector &tv)

u|tv

inline UnitaryVector xlifepp::operator|(const UnitaryVector &n1, const UnitaryVector &n2)

inner product of unitary vector (_nx|_ny) -> _nxdotny

OperatorOnUnknown &xlifepp::operator|(const Unknown&, const complex_t&)

u|c

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 ndot(u)

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

OperatorOnUnknown &xlifepp::operator|(const Unknown &un, const GeomDomain &dom)

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

innerproduct syntax V|Op(u)

OperatorOnFunction &xlifepp::operator|(const Vector<complex_t> &v, UnitaryVector n)

v|n same as f_v|n

OperatorOnFunction &xlifepp::operator|(const Vector<real_t> &v, UnitaryVector n)

v|n same as f_v|n

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)

OperatorOnFunction &xlifepp::operator|(OperatorOnFunction&, UnitaryVector)

opf|n

OperatorOnKernel &xlifepp::operator|(OperatorOnKernel&, UnitaryVector)

opker|n

OperatorOnUnknown &xlifepp::operator|(OperatorOnUnknown&, const Function&)

innerproduct syntax Op(u)|F

OperatorOnUnknown &xlifepp::operator|(OperatorOnUnknown&, const OperatorOnFunction&)

innerproduct syntax Op(u)|op(F)

OperatorOnUnknown &xlifepp::operator|(OperatorOnUnknown&, const Value&)

innerproduct syntax Op(u)|V

OperatorOnUnknowns xlifepp::operator|(OperatorOnUnknown&, OperatorOnUnknown&)

opu | opv

OperatorOnUnknown &xlifepp::operator|(OperatorOnUnknown&, UnitaryVector)

grad(u)|n same as ndotgrad(u)

OperatorOnUnknowns xlifepp::operator|(OperatorOnUnknown&, Unknown&)

opu | v

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

OperatorOnUnknown &xlifepp::operator|(OperatorOnUnknown &opu, const GeomDomain &dom)

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 Space &xlifepp::operator|(Space &sp, const GeomDomain &dom)

Parameters:

dom – return sub-space or trace space on domain of a space, created if not exist

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 Vector<complex_t> &v)

n|v same as n|f_v

OperatorOnFunction &xlifepp::operator|(UnitaryVector n, const Vector<real_t> &v)

n|v same as n|f_v

OperatorOnFunction &xlifepp::operator|(UnitaryVector, const Function&)

n|f same as ndot(f)

OperatorOnKernel &xlifepp::operator|(UnitaryVector, const Kernel&)

n|ker same as ndot(ker)

OperatorOnUnknown &xlifepp::operator|(UnitaryVector, const Unknown&)

n|u same as ndot(u)

OperatorOnFunction &xlifepp::operator|(UnitaryVector, OperatorOnFunction&)

n|opf

OperatorOnKernel &xlifepp::operator|(UnitaryVector, OperatorOnKernel&)

n|opker

OperatorOnUnknown &xlifepp::operator|(UnitaryVector, OperatorOnUnknown&)

n|grad(u) same as ndotgrad(u)

OperatorOnUnknowns xlifepp::operator|(Unknown&, OperatorOnUnknown&)

u | opv

OperatorOnUnknowns xlifepp::operator|(Unknown&, Unknown&)

u | v

operator||

template<typename T>
ComparisonFunction<T> xlifepp::operator||(const ComparisonFunction<T> &cof1, const ComparisonFunction<T> &cof2)

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

operator~

CircArc xlifepp::operator~(const CircArc &c)

parametrization c+(a-c)cos(t)+(b-c)sin(t) t=(1-x)*thetamin + x*thetamax with x=pt[0] in [0,1]

copy a CircArc and reverse its orientation

EllArc xlifepp::operator~(const EllArc &e)

parametrization c+(a-c)cos(s)+(b-c)sin(s) with s = thetamin+ t*(thetamax-thetamin), t in [0,1]

copy a EllArc and reverse its orientation

inline Geometry &xlifepp::operator~(const Geometry &g)

ParametrizedArc xlifepp::operator~(const ParametrizedArc &s)

copy a ParametrizedArc and reverse its orientation

Segment xlifepp::operator~(const Segment &s)

copy a Segment and reverse its orientation

SplineArc xlifepp::operator~(const SplineArc &s)

inverse of parametrization

copy a SplineArc and reverse its orientation

inline SymbolicTermMatrix &xlifepp::operator~(const TermMatrix &M)

opName

string_t xlifepp::opName(SymbolicOperation o)

orthogonalPoint

inline Point xlifepp::orthogonalPoint(const Point &P)

orthogonalPoint3D

inline Point xlifepp::orthogonalPoint3D(const Point &P)

outwardNormalsOfTriangle

std::vector<std::vector<real_t>> xlifepp::outwardNormalsOfTriangle(const Point &T1, const Point &T2, const Point &T3)

computation of outward normals to the triangle whose vertices are T1, T2 and T3 normals[0] : outward normal of [T2T3] normals[1] : outward normal of [T1T3] normals[2] : outward normal of [T1T2]

outward normals to a triangle with given vertices

over4pir

void xlifepp::over4pir(const Point&, const Point&, real_t&)

\(1/(4\pi r)\)

parametrization_BezierSpline

inline Vector<real_t> xlifepp::parametrization_BezierSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_BSpline

inline Vector<real_t> xlifepp::parametrization_BSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_C2Spline

inline Vector<real_t> xlifepp::parametrization_C2Spline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_CatmullRomSpline

inline Vector<real_t> xlifepp::parametrization_CatmullRomSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_CircArc

inline Vector<real_t> xlifepp::parametrization_CircArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_EllArc

inline Vector<real_t> xlifepp::parametrization_EllArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Ellipse

inline Vector<real_t> xlifepp::parametrization_Ellipse(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_EllipsoidSidePart

inline Vector<real_t> xlifepp::parametrization_EllipsoidSidePart(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Nurbs

inline Vector<real_t> xlifepp::parametrization_Nurbs(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Parallelogram

inline Vector<real_t> xlifepp::parametrization_Parallelogram(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_ParametrizedArc

inline Vector<real_t> xlifepp::parametrization_ParametrizedArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Piecewise

inline Vector<real_t> xlifepp::parametrization_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Quadrangle

inline Vector<real_t> xlifepp::parametrization_Quadrangle(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Segment

inline Vector<real_t> xlifepp::parametrization_Segment(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_SplineArc

inline Vector<real_t> xlifepp::parametrization_SplineArc(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_SplineSurface

inline Vector<real_t> xlifepp::parametrization_SplineSurface(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parametrization_Triangle

inline Vector<real_t> xlifepp::parametrization_Triangle(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call (Duffy)

parametrization_TrunkSidePart

inline Vector<real_t> xlifepp::parametrization_TrunkSidePart(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

parfun_error

inline void xlifepp::parfun_error(const string_t &com, DiffOpType d)

parmap_error

inline void xlifepp::parmap_error(const string_t &com, number_t d)

parseEigenPars

void xlifepp::parseEigenPars(const std::vector<Parameter> ps, const number_t nevmax, std::set<ParameterKey> &usedParams, EigPars &ep)

Parser of user parameters for eigen solvers (internal tool) Returns the list of parameter keys specified by the user (usedParams) and the parameter values to be used (ep).

Nota: the solver parameter is skipped.

permute

template<typename T>
std::vector<T> &xlifepp::permute(std::vector<T> &v, std::vector<T> &vp, const std::vector<number_t> &p)

permutation of a vector v: vector to be permuted vp: permuted vector p: permutation (index starts from 0) permutation is driven by the permutation vector p that may be smaller than the vector v (but not larger!): vp[i]= v[p[i]] i=0, p.size()

permuteInv

template<typename T>
std::vector<T> &xlifepp::permuteInv(std::vector<T> &v, std::vector<T> &vp, const std::vector<number_t> &p)

inverse permutation of a vector v: vector to be permuted vp: permuted vector p: permutation (index starts from 0) permutation is driven by the permutation vector p that may be smaller than the vector v (but not larger!): vp[p[i]]= v[i] i=0, p.size()

physicalDomain

string_t xlifepp::physicalDomain(const std::vector<string_t> &names, const string_t &sid, std::vector<PhysicalData> &pids)

create geo Physical domain string from names and the type of domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from names and type of side domain sd = “P” or “L” or “E” or “S”

string_t xlifepp::physicalDomain(const std::vector<string_t> &sidenames, const Strings &sids, std::vector<PhysicalData> &pids)

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from sidenames and type of side domain sd = “P” or “L” or “E” or “S”

string_t xlifepp::physicalDomain(const string_t &domName, const string_t &sid, dimen_t dim, std::vector<PhysicalData> &pids)

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from domain name, surface id, and dimension

string_t xlifepp::physicalDomain(const string_t &domName, const Strings &sids, dimen_t dim, std::vector<PhysicalData> &pids)

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from domain name, surface ids, and dimension

physicalDomainForExtrusion

string_t xlifepp::physicalDomainForExtrusion(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const string_t &sd, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids, real_t angle)

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S” for extrusion geometries

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

physicalDomains

string_t xlifepp::physicalDomains(const std::vector<PhysicalData> &pids)

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

pictureCrack

void xlifepp::pictureCrack(const std::set<GeomElement*> &elts1, const std::set<GeomElement*> &elts2, const string_t &fn)

planeNormal

Vector<real_t> xlifepp::planeNormal(const Point &p, bool fromParameters, Parameters &pars)

function returning the plane normal stored in Parameters pars

planeSurfaceFrom

inline Geometry xlifepp::planeSurfaceFrom(const Geometry &c, string_t domName = "")

definition of a geometry 2D from an union of boundaries 1D

plot

void xlifepp::plot(const TermVector &tv, IOFormat iof)

plot a TermVector using external call of appropriate viewer

plotting a TermVector

point_to_xyz

inline Vector<real_t> xlifepp::point_to_xyz(const Point &p, Parameters &pa = defaultParameters)

pointDistance

real_t xlifepp::pointDistance(const Point&, const Point&)

returns distance between two points

pointer

const void *xlifepp::pointer(const Parameter&)

cast to const void *

pointInElement

bool xlifepp::pointInElement(const Point &P, const GeomElement &E, real_t tol)

pointInPolygon

bool xlifepp::pointInPolygon(const Point &p, const Geometry &g)

pointInPolyhedron

bool xlifepp::pointInPolyhedron(const Point &p, const Geometry &g)

pointOrientation2D

int xlifepp::pointOrientation2D(const Point &A, const Point &B, const Point &C, real_t tol)

determines if points A, B and C are colinear (returns 0) or a clockwise triangle (returns 1) or a counter-clockwise triangle (returns 2). A, B and C are supposed to be 2D points (not checked)

determines if points A, B and C are colinear, a clockwise triangle or a counter-clockwise triangle

pointQuadrature

Quadrature *xlifepp::pointQuadrature(QuadRule rule, number_t deg)

pointReflect

template<class Geom>
Geom xlifepp::pointReflect(const Geom &g, const Parameter &p1)

apply a point reflection on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::pointReflect(const Geom &g, const Point &c = Point(0., 0., 0.))

apply a point reflection on a Geom (template external)

inline Geometry xlifepp::pointReflect(const Geometry &g, const Parameter &p1)

apply a point reflection on a Geometry (1 key) (template external)

inline Geometry xlifepp::pointReflect(const Geometry &g, const Point &c = Point(0., 0., 0.))

apply a point reflection on a Geometry (template external)

Mesh xlifepp::pointReflect(const Mesh &m, const Parameter &p1)

apply a point reflection on a Mesh (1 key)

apply a point reflection on a Mesh (1 keys) (external)

Mesh xlifepp::pointReflect(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a point reflection on a Mesh (2 keys)

apply a point reflection on a Mesh (2 keys) (external)

Mesh xlifepp::pointReflect(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a point reflection on a Mesh (3 keys)

apply a point reflection on a Mesh (3 keys) (external)

Mesh xlifepp::pointReflect(const Mesh &m, const Point &c)

apply a point reflection on a Mesh (external)

inline Point xlifepp::pointReflect(const Point &g, const Parameter &p1)

apply a point reflection on a Point (1 key) (template external)

inline Point xlifepp::pointReflect(const Point &g, const Point &c = Point(0., 0., 0.))

apply a point reflection on a Point (template external)

pow

inline SuTermVector xlifepp::pow(const SuTermVector &s, const real_t &p)

inline SymbolicFunction &xlifepp::pow(const SymbolicFunction &f, const double &p)

inline TermVector xlifepp::pow(const TermVector &s, const real_t &p)

power

inline SymbolicFunction &xlifepp::power(const real_t &r, const SymbolicFunction &f)

inline SymbolicFunction &xlifepp::power(const SymbolicFunction &f, const real_t &r)

inline SymbolicFunction &xlifepp::power(const SymbolicFunction &f1, const SymbolicFunction &f2)

template<typename K>
Vector<K> xlifepp::power(const Vector<K> &v, real_t n)

log(v)

preComputationFE

inline void xlifepp::preComputationFE(Space *subsp, const MeshDomain *dom, std::set<Quadrature*> &quads, dimen_t nbc, bool der1, bool der2, bool invertJacobian, bool nor, bool mapquad, bool useAux, bool isogeo)

preComputationIE

void xlifepp::preComputationIE(const GeomDomain &dom, const Space *subsp, std::set<Quadrature*> &quads, dimen_t nbc, bool useAux, bool der1, bool der2, bool nor, bool extendedDomain, bool isogeo)

precompute geometry data and shape values on any element for any quadrature involved restricted to one order geometric element, take large place but computation is then faster in case of IE!!!

precompute geometry data and shape values on any element for any quadrature involved

dom: integration domain subsp: subspace providing the list of elements quads: list of quadratures nbc: number of components of the unknown useAux: use relt->qshvs_aux to store shapevalues (occurs when relt->qshvs_ is already used) der1: compute shape first derivatives if true der2: compute shape second derivatives if true nor: compute normal if true extendedDomain: true when dealing with an extended domain isogeo : if true, use domain parametrization in geometric computation

preComputationIE_old

void xlifepp::preComputationIE_old(const Space *subsp, std::set<Quadrature*> &quads, dimen_t nbc, bool der1, bool der2, bool nor)

precompute geometry data and shape values on any element for any quadrature involved restricted to one order geometric element, take large place but computation is then faster in case of IE!!!

subsp: subspace providing the list of elements quads: list of quadratures nbc: number of components of the unknown der1: compute shape first derivatives if true der2: compute shape second derivatives if true nor: compute normal if true

prepareLinearSystem

TermVector xlifepp::prepareLinearSystem(TermMatrix&, TermVector&, MatrixEntry*&, VectorEntry*&, StorageType, AccessType, bool)

prepare linear system AX=B (internal tool)

print

void xlifepp::print(const Parameter &p)

void xlifepp::print(const Parameters&)

extern print to default ostream

printAllInMemory

void xlifepp::printAllInMemory(PrintStream &os, size_t vb)

void xlifepp::printAllInMemory(std::ostream &os, size_t vb)

printCoo

void xlifepp::printCoo(std::ostream &os, const complex_t &v, number_t i, number_t j, real_t tol)

template<typename T>
void xlifepp::printCoo(std::ostream &os, const Matrix<T> &v, number_t i, number_t j, real_t tol = theTolerance)

void xlifepp::printCoo(std::ostream &os, const real_t &v, number_t i, number_t j, real_t tol)

printDense

void xlifepp::printDense(std::ostream&, const complex_t&, number_t)

print complex scalar in dense format

void xlifepp::printDense(std::ostream&, const real_t&, number_t)

print real scalar in dense format

template<typename T>
void xlifepp::printDense(std::ostream &os, const Matrix<T> &v, number_t k)

print row of Matrix in dense format

printListDiffOp

void xlifepp::printListDiffOp(CoutStream&)

print the list of differential operators (check utility)

void xlifepp::printListDiffOp(std::ostream&)

print the list of differential operators (check utility)

printMatrixStorages

inline void xlifepp::printMatrixStorages(PrintStream &os)

void xlifepp::printMatrixStorages(std::ostream&)

print list of MatrixStorage’s

printRowWise

template<typename Iterator>
void xlifepp::printRowWise(std::ostream &os, const string_t &title, number_t perRow, number_t width, Iterator it1, Iterator it2)

prints container of integer type on opened ostream with a constant number of entries per row; requires “operator<<” this is a stl-like utility: iterators are either stl::iterators or C-pointers

template<typename Iterator>
void xlifepp::printRowWise(std::ostream &os, const string_t &title, number_t perRow, number_t width, number_t prec, Iterator it1, Iterator it2)

prints container of real or complex type on opened ostream with a constant number of entries per row; requires “operator<<” this is a stl-like utility: iterators are either stl::iterators or C-pointers

printVector

template<typename K>
void xlifepp::printVector(std::ostream &os, const string_t &s, const std::vector<K> &v)

prismLagrangeStd

RefElement *xlifepp::prismLagrangeStd(const Interpolation *interp_p)

prismLagrangeStd construction of a prismatic Lagrange Reference Element by interpolation number

Extern class related functions and declarations.

prismQuadrature

Quadrature *xlifepp::prismQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit prism

prismValid

bool xlifepp::prismValid(const std::set<std::pair<number_t, Point>, SortPointsByXAndY> &face1, const std::set<std::pair<number_t, Point>, SortPointsByXAndY> &face2)

determines if a prism defined by its triangular faces is valid or not faces must coincide first point of each face has coordinates xmin and ymin

projection

TermVector xlifepp::projection(const TermVector &X, Space &W, const Unknown &u, ProjectorType pt, KeepStatus keep)

TermVector xlifepp::projection(const TermVector &X, Space &W, dimen_t nbcW, const Unknown &u, ProjectorType pt, KeepStatus keep)

TermVector xlifepp::projection(const TermVector &X, Space &W, dimen_t nbcW, ProjectorType pt, KeepStatus keep)

TermVector xlifepp::projection(const TermVector &X, Space &W, ProjectorType pt, KeepStatus keep)

projectionOfPointOnPlane

Point xlifepp::projectionOfPointOnPlane(const Point &M, const Point &P1, const Point &P2, const Point &P3, real_t &h, bool only3D)

orthogonal projection of point M on plane defined by 3 non aligned given points (P1, P2, and P3) returns the projected point P and the distance h between M and the plane

orthogonal projection of a point on a plane

projectionOfSegmentOnPlane

std::pair<Point, Point> xlifepp::projectionOfSegmentOnPlane(const Point &S1, const Point &S2, const Point &P1, const Point &P2, const Point &P3, real_t &h)

orthogonal projection of segment defined by the points T1 and T2 on the parallel plane defined by the 3 non aligned given points S1, S2, and S3 returns the projected points and the distance h between the segment and the plane

orthogonal projection of a segment on a parallel plane

projectionOfTriangleOnPlane

std::vector<Point> xlifepp::projectionOfTriangleOnPlane(const Point &T1, const Point &T2, const Point &T3, const Point &P1, const Point &P2, const Point &P3, real_t &h)

orthogonal projection of triangle defined by the points T1, T2 and T3 on the parallel plane defined by the 3 non aligned given points P1, P2, and P3 returns the projected points and the distance h between the triangle and the plane

orthogonal projection of a triangle on a parallel plane

projectionOnQuadrangle

Point xlifepp::projectionOnQuadrangle(const Point &M, const Point &Q1, const Point &Q2, const Point &Q3, const Point &Q4, real_t &h)

projection (minimal distance) of point M on quadrangle given by vertices Q1, Q2, Q3, Q4 (assuming Q1, Q2, Q3, Q4 are coplanar) returns the projected point P and the distance h=MP (2D-3D)

projection (minimal distance) of point M on quadrangle given points Q1, Q2, Q3 and Q4 (assuming Q1, Q2, Q3 and Q4 are coplanar)

projectionOnSegment

Point xlifepp::projectionOnSegment(const Point &M, const Point &A, const Point &B, real_t &h)

projection (minimal distance) of a point M on segment [AB] returns the projected point P and the distance h=MP

projection (minimal distance) of a point M on the segment defined points A, B

projectionOnStraightLine

Point xlifepp::projectionOnStraightLine(const Point &M, const Point &A, const Point &B, real_t &h, bool only3D)

orthogonal projection of a point M on a straight line defined by 2 points (A and B) returns the projected point P and the distance h=MP

orthogonal projection of a point on a straight line

projectionOnTetrahedron

Point xlifepp::projectionOnTetrahedron(const Point &M, const Point &T1, const Point &T2, const Point &T3, const Point &T4, real_t &h)

projection (minimal distance) of point M on tetrahedron given vertices T1, T2, T3 and T4 returns the projected point P and the distance h=MP (3D)

projection (minimal distance) of point M on tetrahedron given points T1, T2, T3 and T4

projectionOnTriangle

Point xlifepp::projectionOnTriangle(const Point &M, const Point &T1, const Point &T2, const Point &T3, real_t &h)

projection (minimal distance) of point M on triangle given vertices T1, T2, and T3 returns the projected point P and the distance h=MP (2D-3D)

projection (minimal distance) of point M on triangle given vertices T1, T2, and T3

pyramidLagrangeStd

RefElement *xlifepp::pyramidLagrangeStd(const Interpolation *interp_p)

pyramidLagrangeStd construction of a pyramidatic Lagrange Reference Element by interpolation number

Extern class related functions and declarations.

pyramidQuadrature

Quadrature *xlifepp::pyramidQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit pyramid

QR

template<typename T, typename K>
void xlifepp::QR(const LargeMatrix<T> &mat, LargeMatrix<T> *&matR, bool computeQ, LargeMatrix<T> *&matQ, std::vector<K> *rhs, bool &withColPermutation, std::vector<number_t> *&numcol_p, number_t &stop, real_t epsStop = 1.e-10)

QR factorization of rectangular matrix pxn using Housolder method generic algorithm using a column algorithm with dynamic storage creation of matrix results.

mat: matrix to factorize matR: upper triangular matrix p x n stored as ColCsStorage (pointer) matQ: unitary matrix of size p x p stored as RowCsStorage (pointer) computeQ: if true the matrix Q is computed else not rhs: right hand side vector pointer (modified), if 0 no rhs withColPermutation: if true, column may be permuted (more stable factorization). if false and algorithm fails, withColPermutation is forced to true and algorithm is rerun numcol_p: renumbering of columns if they have been permuted (pointer) stop: iteration number when the algorithm stops: stop = nbr when algorithm exits normally epsStop: relative tolerance, the process stops when the pivot is less than epsStop times the largest norm of the columns of the matrix (remaining rows are considered as redundant or conflicting); a relative test is required because the rounding errors accumulated over the Householder steps of a large system may exceed an absolute tolerance

Note 1 : to avoid unsightly rounding effect in reduction, values < 10*theEspsilon (~10^-15) are rounded to 0 Note 2 : when there are constraint redanduncies, it may occur some average effects. For instance, two Dirichlet conditions at the same point (in Lagrange interpolation) with different right hand side produce a Dirichlet condition with a mean of right hand sides It may be inconvenient !

void xlifepp::QR(const MatrixEntry &mat, MatrixEntry &matR, bool computeQ, MatrixEntry &matQ, VectorEntry *rhs, bool &withColPermutation, std::vector<number_t> *&numcol, number_t &stop, real_t epsStop)

QR factorization of rectangular matrix pxn with p<=n using Housolder method generic algorithm using a column algorithm with dynamic storage creation of matrix results mat: matrix to factorize matR: upper triangular matrix p x n stored as ColCsStorage matQ: unitary matrix of size p x p stored as RowCsStorage computeQ: if true the matrix Q is computed else not rhs: right hand side vector pointer (if 0 not reduction for rhs) withColPermutation: if true, column may be permuted (more stable factorization), may be forced by algorithm numcol_p: renumbering of columns if they have been permuted (pointer) stop: iteration number when the algorithm stops: stop = nbr when algorithm exits normally.

QR factorisation (relative stopping tolerance)

qr

template<typename T>
void xlifepp::qr(const Matrix<T> &A, Matrix<T> &Q, Matrix<T> &R)

QR factorization.

template<typename T>
void xlifepp::qr(const T *A, number_t m, number_t n, T *Q, T *R)

general template QR using Eigen, assuming A, Q, R are pointers to first value of dense row matrix A: pointer to dense row matrix m,n: number of rows and cols of A Q, R: pointer to QR factors as dense row matrices, has to be allocated before

QRSolve

template<typename T, typename K>
void xlifepp::QRSolve(const LargeMatrix<T> &mat, LargeMatrix<T> *mat2, std::vector<K> *rhs)

template<typename T, typename K>
void xlifepp::QRSolve(const LargeMatrix<T> &mat, std::vector<std::vector<std::pair<number_t, K>>> &rhss)

solve upper triangular system pxp with diag = Id with a list of right hand sides each right hand side is a vector of pairs (row index, value) using a column algorithm with dynamic storage update p | 1 x … x | | 0 1 … x | at = | … | | 0 0 1 x | | 0 0 1 |

mat: upper triangular matrix rhss: list of right hand sides

rhss is overwritten !

void xlifepp::QRSolve(const MatrixEntry &mat, MatrixEntry *matR, VectorEntry *rhs)

solve an pxp upper triangular system mat: pxp upper triangular matrix with its diagonal coeffs = 1, matR: rectangular matrix p x m, understood as a list of right hand side vectors of size p (if 0 no computation for matR) rhs: a unique right hand side vector pointer (if 0 no computation for rhs)

QR solver (only in scalar representation)

At the end, rhs contains the vector x solution of mat * x = rhs and matR contains the vectors x1, x2, …xm solutions of mat * xj = matRj Note: at the end, matR is stored using a cs column storage

quadrangleQuadrature

Quadrature *xlifepp::quadrangleQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit square

quadratic

std::vector<complex_t> xlifepp::quadratic(complex_t a, complex_t b, complex_t c)

computes roots of degree 2 complex polynomial

std::vector<complex_t> xlifepp::quadratic(real_t a, real_t b, real_t c)

computes roots of degree 2 real polynomial

r3svd

template<typename T>
LowRankMatrix<T> &xlifepp::r3svd(const LargeMatrix<T> &lm, LowRankMatrix<T> &lrm, real_t eps = theTolerance, number_t t = 0, number_t p = 0, number_t q = 0, number_t maxit = 0)

r3svd of a LargeMatrix

R3SVD compression method of a LargeMatrix to a LowRankMatrix Lr T: type of the result lm: LargeMatrix to be compressed eps: energy threshold t: number of sampling p: number of over sampling q: power number (q=0 gives the standard r3svd) maxit: maximum of iterations if t = 0, the parameters t, p, q, maxit are determined by function regarding the matrix dimensions lrm: output LowRankMatrix.

template<typename M, typename T>
void xlifepp::r3svd(M &A, real_t eps, number_t &rk, std::vector<T> &U, std::vector<T> &D, std::vector<T> &V, number_t t = 0, number_t p = 0, number_t q = 0, number_t maxit = 0)

improved Random SVD compression method of a matrix of class M from https://arxiv.org/ftp/arxiv/papers/1605/1605.08134.pdf T: type of the result A: matrix of class M, requires the member functions: M::numberOfRows(), M::numberOfCols(), M::squaredNorm() M::multMatrixRow(T* M, T* R, number_t p) i.e M*matRow M::multLeftMatrixRow(T* M, T* R, number_t p) i.e matRow*M eps: energy threshold rk: rank of r3svd on output U, V: vectors storing dense row matrices S: vector storing S t: number of sampling p: number of over sampling q: power number (q=0 gives the standard r3svd) maxit: maximum of iterations if t = 0, the parameters t, p, q, maxit are determined by function regarding the matrix dimensions

template<typename T>
void xlifepp::r3svd(Matrix<T> &A, Matrix<T> &U, Vector<T> &D, Matrix<T> &V, real_t eps = theTolerance, number_t t = 0, number_t ts = 0, number_t q = 0, number_t maxit = 0)

Improved random SVD with precision truncation T: type of the matrix (real or complex) A: Matrix to be be factorized eps: energy threshold U,D,V: SVD factors A~U*D*V’ (output) t, ts: number of sampling and oversampling q: power number (q=0 gives the standard r3svd) maxit: maximum of restart if t = 0, the parameters t, p, q and maxit are determined by function regarding the matrix dimensions.

template<typename T>
void xlifepp::r3svd(T *A, number_t m, number_t n, real_t eps, number_t &rk, T *U, T *D, T *V, number_t t = 0, number_t p = 0, number_t q = 0, number_t maxit = 0)

improved Random SVD compression method of a row dense matrix given by pointer from https://arxiv.org/ftp/arxiv/papers/1605/1605.08134.pdf

T: type of the result A: pointer to the first element of the dense matrix to be compressed, stored as row major access (dense row) m, n: number of rows and cols of matrix to be compressed eps: energy threshold rk: rank of r3svd on output U, V: pointer to dense row matrices, has to be allocated before D: pointer to S vector, has to be allocated before t: number of sampling p: number of over sampling q: power number (q=0 gives the standard r3svd) maxit: maximum of iterations if t = 0, the parameters t, p, q, maxit are determined by function regarding the matrix dimensions

note: may be used when A is a pointer to a m x n col dense matrix, by permuting arguments when calling: r3svd(A,n,m,eps,V,D,U, t, p ,q, maxit) produces the R3SVD of A = U*D*V’ where U, V are pointers to row dense matrices!

ranks

template<typename T, typename N>
void xlifepp::ranks(const std::map<T, N> &M, const std::vector<T> &V, std::vector<N> &R)

return in R the ranks of V components in U vector, not assuming that U and V are sorted, N index starts from 1 except if V[k] is not found in map then R[k]=0 faster than previous ranks function but requires a map

template<typename T, typename N>
void xlifepp::ranks(const std::vector<T> &U, const std::vector<T> &V, std::vector<N> &R)

return in R ranks of V components in U vector, not assuming that U and V are sorted index starts from 1 expansive if U and V are large

template<typename itT, typename itN>
void xlifepp::ranks(itT itu_b, itT itu_e, itT itv_b, itT itv_e, itN itr_b)

return in R ranks of V components in U container, not assuming that U and V are sorted (index starts from 1) expansive if U and V are large itu_b, itu_e: begin and end iterator for container U itv_b, itv_e: begin and end iterator for container V itr_b: begin iterator for container R (R has to be sized to V size before)

itN must support conversion from Number

readEntities

template<class T_>
void xlifepp::readEntities(T_ &data, size_t numEnt, Mn_Sn &phystag)

readEntitiesBin

template<class T_>
void xlifepp::readEntitiesBin(T_ &data, size_t numEnt, Mn_Sn &phystag)

readfmt2

template<class T_>
void xlifepp::readfmt2(T_ &data, const string_t &filename, const vector<CrackData> &crackData, number_t &nb_geom_Pts, vector<real_t> &PointCoords, vector<number_t> &nodeNum, bool &planeDomain, bool &curveDomain, number_t &nb_elts, vector<GELT> &gelts, ELTDEFMAP &elMap, dimen_t &elementDimx, const GMSHMAP &gmMap, set<number_t> &domSet, map<number_t, set<number_t>> &crackedDomSet, map<number_t, number_t> &it_inCrackData, map<number_t, string_t> &domNameMap, bool &isMadeOfSimplices_)

readfmt2Bin

void xlifepp::readfmt2Bin(FILE *&data, const string_t &filename, const vector<CrackData> &crackData, number_t &nb_geom_Pts, vector<real_t> &PointCoords, vector<number_t> &nodeNum, bool &planeDomain, bool &curveDomain, number_t &nb_elts, vector<GELT> &gelts, ELTDEFMAP &elMap, dimen_t &elementDimx, const GMSHMAP &gmMap, set<number_t> &domSet, map<number_t, set<number_t>> &crackedDomSet, map<number_t, number_t> &it_inCrackData, map<number_t, string_t> &domNameMap, bool &isMadeOfSimplices_)

void xlifepp::readfmt2Bin(std::ifstream &data, const string_t &filename, const vector<CrackData> &crackData, number_t &nb_geom_Pts, vector<real_t> &PointCoords, vector<number_t> &nodeNum, bool &planeDomain, bool &curveDomain, number_t &nb_elts, vector<GELT> &gelts, ELTDEFMAP &elMap, dimen_t &elementDimx, const GMSHMAP &gmMap, set<number_t> &domSet, map<number_t, set<number_t>> &crackedDomSet, map<number_t, number_t> &it_inCrackData, map<number_t, string_t> &domNameMap, bool &isMadeOfSimplices_)

readfmt4

template<class T_>
void xlifepp::readfmt4(T_ &data, const string_t &filename, const vector<CrackData> &crackData, number_t &nb_geom_Pts, vector<real_t> &PointCoords, vector<number_t> &nodeNum, bool &planeDomain, bool &curveDomain, number_t &nb_elts, vector<GELT> &gelts, ELTDEFMAP &elMap, dimen_t &elementDimx, const GMSHMAP &gmMap, set<number_t> &domSet, map<number_t, set<number_t>> &crackedDomSet, map<number_t, number_t> &it_inCrackData, map<number_t, string_t> &domNameMap, bool &isMadeOfSimplices_)

readfmt4Bin

void xlifepp::readfmt4Bin(FILE *&data, const string_t &filename, const vector<CrackData> &crackData, number_t &nb_geom_Pts, vector<real_t> &PointCoords, vector<number_t> &nodeNum, bool &planeDomain, bool &curveDomain, number_t &nb_elts, vector<GELT> &gelts, ELTDEFMAP &elMap, dimen_t &elementDimx, const GMSHMAP &gmMap, set<number_t> &domSet, map<number_t, set<number_t>> &crackedDomSet, map<number_t, number_t> &it_inCrackData, map<number_t, string_t> &domNameMap, bool &isMadeOfSimplices_)

void xlifepp::readfmt4Bin(std::ifstream &data, const string_t &filename, const vector<CrackData> &crackData, number_t &nb_geom_Pts, vector<real_t> &PointCoords, vector<number_t> &nodeNum, bool &planeDomain, bool &curveDomain, number_t &nb_elts, vector<GELT> &gelts, ELTDEFMAP &elMap, dimen_t &elementDimx, const GMSHMAP &gmMap, set<number_t> &domSet, map<number_t, set<number_t>> &crackedDomSet, map<number_t, number_t> &it_inCrackData, map<number_t, string_t> &domNameMap, bool &isMadeOfSimplices_)

readInt

inline void xlifepp::readInt(FILE *data, number_t &Val)

inline void xlifepp::readInt(std::ifstream &data, number_t &Val)

readIntBin

inline void xlifepp::readIntBin(FILE *data, number_t &Val)

inline void xlifepp::readIntBin(std::ifstream &data, number_t &Val)

readItem

void xlifepp::readItem(std::istream&, complex_t&, bool isreal = false)

read complex item from istream

void xlifepp::readItem(std::istream&, real_t&, bool isreal = true)

read real item from istream

readPartitionedEntities

template<class T_>
void xlifepp::readPartitionedEntities(T_ &data, size_t numEnt, Mn_Pnn &parentDT, Mn_Sn &partparttag, Mn_Sn &partphystag)

readPartitionedEntitiesBin

template<class T_>
void xlifepp::readPartitionedEntitiesBin(T_ &data, size_t numEnt, Mn_Pnn &parentDT, Mn_Sn &partparttag, Mn_Sn &partphystag)

readPhysNames

template<class T_>
void xlifepp::readPhysNames(T_ &data, map<number_t, string_t> &domNameMap)

readPlyElement

string_t xlifepp::readPlyElement(PlyElement &e, std::istream &data)

read element and its properties

readRea

inline void xlifepp::readRea(FILE *data, real_t &Val)

inline void xlifepp::readRea(std::ifstream &data, real_t &Val)

readReaBin

inline void xlifepp::readReaBin(std::ifstream &data, real_t &Val)

readStr

inline bool xlifepp::readStr(FILE *data, string_t &Val)

inline bool xlifepp::readStr(std::ifstream &data, string_t &Val)

readStrBin

inline bool xlifepp::readStrBin(std::ifstream &data, string_t &Val)

real

real_t xlifepp::real(const Parameter&)

cast to real_t

inline SymbolicFunction &xlifepp::real(const SymbolicFunction &f)

TermMatrix xlifepp::real(const TermMatrix &tm)

return real part as a real TermMatrix

TermVector xlifepp::real(const TermVector &tv)

extracts real part

Vector<real_t> xlifepp::real(const Vector<complex_t> &a)

real part of a complex vector

Vector<real_t> xlifepp::real(const Vector<real_t> &a)

real part of a real vector

Vector<Vector<real_t>> xlifepp::real(const Vector<Vector<complex_t>> &a)

abs of a vector of complex vectors

real part of a vector of complex vectors

Vector<Vector<real_t>> xlifepp::real(const Vector<Vector<real_t>> &a)

abs of a vector of real vectors

real part of a vector of real vectors

real_const_fun

real_t xlifepp::real_const_fun(const Point &P, Parameters &pa)

real_matrix_const_fun

Matrix<real_t> xlifepp::real_matrix_const_fun(const Point &P, Parameters &pa)

real_vector_const_fun

Vector<real_t> xlifepp::real_vector_const_fun(const Point &P, Parameters &pa)

realPart

inline real_t xlifepp::realPart(const complex_t&)

Matrix<real_t> xlifepp::realPart(const Matrix<complex_t> &cB)

real part of a complex matrix

Matrix<real_t> xlifepp::realPart(const Matrix<real_t> &cB)

real part of a real matrix

inline real_t xlifepp::realPart(const real_t&)

inline SuTermVector xlifepp::realPart(const SuTermVector &s)

mathematical function applied to SuTermVector

realTpl

template<typename T1_iterator, typename R_iterator>
void xlifepp::realTpl(T1_iterator b1, T1_iterator e1, R_iterator Rb)

returns real part of vector entries: R[i] = real(T1[i])

rebuild

void xlifepp::rebuild(GeomDomain &dom, const ComparisonFunction<> &cr)

rebuild one plain domain

rebuild 1 plain domain

void xlifepp::rebuild(GeomDomain &dom, const ComparisonFunction<> &cr, GeomDomain &sdom)

rebuild one plain domain and one side domain

rebuild 1 plain domain and one side domain

void xlifepp::rebuild(GeomDomain &dom1, const ComparisonFunction<> &cr1, GeomDomain &dom2, const ComparisonFunction<> &cr2)

rebuild 2 plain domains

void xlifepp::rebuild(GeomDomain &dom1, const ComparisonFunction<> &cr1, GeomDomain &dom2, const ComparisonFunction<> &cr2, GeomDomain &sdom)

rebuild 2 plain domains and one side domain

rebuild 2 plain domains

rebuild 2 plain domains and one side domain

void xlifepp::rebuild(GeomDomain &dom1, const ComparisonFunction<> &cr1, GeomDomain &dom2, const ComparisonFunction<> &cr2, GeomDomain &sdom1, GeomDomain &sdom2)

rebuild 2 plain domains and two side domains

void xlifepp::rebuild(std::vector<GeomDomain*> &doms, const std::vector<ComparisonFunction<>> &crs, const std::set<GeomDomain*> &sidedoms)

rebuild some plain domains using criteria, the rebuilding works as follow:

rebuild some plain domains

• rebuild each of given domains by using ComparisonFunction and element color

• update side domains related to given domains (boundary or interface)

ComparaisonFunction’s are objects that handles simple boolean expressions involving boolean operator (e.g. _color == 0) For instance to update two domains dom1, dom2 distinguished by values 0 and 1 rebuild(dom1, _color==0, dom2, _color==1);

doms: list of domain to be rebuilt crs: list of related comparison criteria sidedoms: set of side domains to be rebuilt, if empty rebuild all side domains found rebuild some plain domains

rebuildEliminatedComponents

void xlifepp::rebuildEliminatedComponents(VectorEntry *x, const std::vector<DofComponent> &cdofs, const Constraints *cons)

rectangle

template<typename T>
T xlifepp::rectangle(const std::vector<T> &f, real_t h)

template<typename T, typename Iterator>
T xlifepp::rectangle(number_t n, real_t h, Iterator itb, T &intg)

uniform rectangle method from a list of n values uniformaly distributed (step h) n: number of values h: step itb: first position in the list of values intg: value of integral: h sum k=1,n v_k

template<typename T>
T xlifepp::rectangle(T (*f)(real_t), real_t a, real_t b, number_t n)

uniform rectangle method on [a,b] interval from a function and a number of subdivisions

template<typename T>
T xlifepp::rectangle(T (*f)(real_t, Parameters&), Parameters &pars, real_t a, real_t b, number_t n)

uniform rectangle method on [a,b] interval from a function with parameters and a number of subdivisions

reducedColumns

static std::vector<std::vector<std::pair<number_t, complex_t>>> xlifepp::reducedColumns(const Constraints &cs)

perform pseudo reduction of reduced essential conditions in a matrix.

Essential conditions have the following form : U_E + F*U_R = H for column unknown U V_E + G*V_R = 0 for row test function V (generally related to unknown U) where E are the eliminated unknown/test function indices and R are the reduced unknown/test function indices other indices S correspond to dofs not connected to the essential conditions dofs The pseudo reduction of matrix consists in

• modifying column A.j for j in R by adding -Fkj*A.k for k in E and replacing column A.k for k in E by a 0 column

• modifying row Ai. for i in R by adding -Gki*Ak. for k in E and replacing row Ak. for k in E by a 0 row

• if eliminated v unknowns are dual of eliminated u unknowns (G=F), the VE rows are replaced by the equation (or a part of) a*U_E + a*F*U_R = a*H where a is a given scalar to delay the right hand side modification, the (A.k) columns (k in E) are stored in a new structure

At the end of the process, the eliminated system looks like (C the correction matrix mxE get from reduction of the constaints)

               U_E       U_R     U_S        U        RHS
           ----------------------------   -------   -------
           |          |        |      |   |     |   |     |
      V_E  | (a+b)*Id |  a*F   |   0  |   | U_E |   | a*H |    => (a+b)*U_E + a*F*U_R = a*H (mimics the constraints)
           |          |        |      |   |     |   |     |
           ----------------------------   -------   -------
           |          |        |      |   |     |   |     |
      V_R  |     0    |  A_RR  | A_RS | * | U_R | = | B_R |    = B0_R - C_RE*H -Gt*B0_E  (rhs correction on reduced dof)
           |          |        |      |   |     |   |     |
           ----------------------------   -------   ------
           |          |       |       |   |     |   |     |
      V_S  |     0    |  A_SR | A_SS  |   | U_S |   | B_S |    = B0_S - C_SE*H           (rhs correction on free dofs)
           |          |       |       |   |     |   |     |
           ----------------------------   -------   -------

If F=G=0 (Dirichlet condition) , R={} and the system reads

               U_E       U_S         U        RHS
           --------------------   -------   -------
           |          |       |   |     |   |     |
      V_E  | (a+b)*Id |   0   |   | U_E |   | a*H |    => (a+b)*U_E = a*H  (constraints)
           |          |       |   |     |   |     |
           -------------------  * ------- = -------
           |          |       |   |     |   |     |
      V_S  |     0    |  A_SS |   | U_S |   | B_S |    = B0_S - C_SE*H    (rhs correction)
           |          |       |   |     |   |     |
           --------------------   -------   -------
           for homogeneous dirichlet condition H=0 and B_S = B0_S!

In some cases (F=G=0 or non dof coupling condition…) the storage is not modified but in other cases (transmission condition for instance) the storage is modified

choosing a=0,b!=0 allows to deal with eigen value problems by shifing the spectra corresponding to eliminated dof

mat : matrix to be eliminated cdofr: row component dofs of matrix cdofc: col component dofs of matrix rhsmat: right hand side matrix pointer

tools for the elimination process, the reduced constraints read U_E + F*U_R = g (see reduceConstraints) the elimination loops travel only the non zero coefficients of F (instead of all the pairs (eliminated, reduced) cdofs)

reducedColumns: non zero coefficients of F by column, fcols[j-1] = list of (i, F(i,j)), i rank of eliminated cdof (1..nbe), j rank of reduced cdof (1..nbr) eliminatedPositions: positions in matrix numbering of eliminated cdofs indexed by their rank (0 if not in matrix) reducedPositions: list of (position in matrix numbering, rank) of reduced cdofs the dual cdof is used when a cdof is not found in the constraints

reducedPositions

static std::vector<std::pair<number_t, number_t>> xlifepp::reducedPositions(const Constraints &cs, const std::map<DofComponent, number_t> &mrecdofs)

reduceMatrix

void xlifepp::reduceMatrix(MatrixEntry *&mat, std::vector<DofComponent> &cdofsr, std::vector<DofComponent> &cdofsc, std::vector<DofComponent> &redcdofsr, std::vector<DofComponent> &redcdofsc, const Constraints *cu, const Constraints *cv)

full reduction of a pseudo-reduced matrix, assuming scalar matrix entries create a new storage from old one by eliminating row en col index related to eliminated dof note: cdofsr and cdofsc are not modified !!!

full reduction of a pseudo-reduced matrix, assuming scalar matrix entries

mat: the matrix to be reduced cdofsr: row dof numbering of mat cdofsc: col dof numbering of mat redcdofsr: row dof numbering of reduced mat redcdofsc: col dof numbering of reduced mat cu, cv: u and v constraint pointers

reflect2d

template<class Geom>
Geom xlifepp::reflect2d(const Geom &g, const Parameter &p1)

apply a reflection 2d on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::reflect2d(const Geom &g, const Parameter &p1, const Parameter &p2)

apply a reflection 2d on a Geom (2 keys) (template external)

template<class Geom>
Geom xlifepp::reflect2d(const Geom &g, const Point &c, real_t dx, real_t dy = 0.)

apply a reflection 2d on a Geom (template external)

template<class Geom>
Geom xlifepp::reflect2d(const Geom &g, const Point &c = Point(0., 0.), std::vector<real_t> d = std::vector<real_t>(2, 0.))

apply a reflection 2d on a Geom (template external)

inline Geometry xlifepp::reflect2d(const Geometry &g, const Parameter &p1)

apply a reflection 2d on a Geometry (1 key) (template external)

inline Geometry xlifepp::reflect2d(const Geometry &g, const Parameter &p1, const Parameter &p2)

apply a reflection 2d on a Geometry (2 keys) (template external)

inline Geometry xlifepp::reflect2d(const Geometry &g, const Point &c, real_t dx, real_t dy = 0.)

apply a reflection 2d on a Geometry (template external)

inline Geometry xlifepp::reflect2d(const Geometry &g, const Point &c = Point(0., 0.), std::vector<real_t> d = std::vector<real_t>(2, 0.))

apply a reflection 2d on a Geometry (template external)

Mesh xlifepp::reflect2d(const Mesh &m, const Parameter &p1)

apply a reflection2d on a Mesh (1 key)

apply a reflection 2D on a Mesh (1 key) (external)

Mesh xlifepp::reflect2d(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a reflection2d on a Mesh (2 keys)

apply a reflection 2D on a Mesh (2 keys) (external)

Mesh xlifepp::reflect2d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a reflection2d on a Mesh (3 keys)

apply a reflection 2D on a Mesh (3 keys) (external)

Mesh xlifepp::reflect2d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

apply a reflection2d on a Mesh (4 keys)

apply a reflection 2D on a Mesh (4 keys) (external)

Mesh xlifepp::reflect2d(const Mesh &m, const Point &c, real_t ux, real_t uy = 0.)

apply a reflection2d on a Mesh (external)

apply a reflection 2D on a Mesh (external)

Mesh xlifepp::reflect2d(const Mesh &m, const Point &c, std::vector<real_t> u = std::vector<real_t>(2, 0.))

apply a reflection2d on a Mesh (external)

apply a reflection 2D on a Mesh (external)

inline Point xlifepp::reflect2d(const Point &g, const Parameter &p1)

apply a reflection 2d on a Point (1 key) (template external)

inline Point xlifepp::reflect2d(const Point &g, const Parameter &p1, const Parameter &p2)

apply a reflection 2d on a Point (2 keys) (template external)

inline Point xlifepp::reflect2d(const Point &g, const Point &c, real_t dx, real_t dy = 0.)

apply a reflection 2d on a Point (template external)

inline Point xlifepp::reflect2d(const Point &g, const Point &c = Point(0., 0.), std::vector<real_t> d = std::vector<real_t>(2, 0.))

apply a reflection 2d on a Point (template external)

reflect3d

template<class Geom>
Geom xlifepp::reflect3d(const Geom &g, const Parameter &p1)

apply a reflection 3d on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::reflect3d(const Geom &g, const Parameter &p1, const Parameter &p2)

apply a reflection 3d on a Geom (2 keys) (template external)

template<class Geom>
Geom xlifepp::reflect3d(const Geom &g, const Point &c, real_t nx, real_t ny, real_t nz = 0.)

apply a reflection 3d on a Geom (template external)

template<class Geom>
Geom xlifepp::reflect3d(const Geom &g, const Point &c = Point(0., 0., 0.), std::vector<real_t> n = std::vector<real_t>(3, 0.))

apply a reflection 3d on a Geom (template external)

inline Geometry xlifepp::reflect3d(const Geometry &g, const Parameter &p1)

apply a reflection 3d on a Geometry (1 key) (template external)

inline Geometry xlifepp::reflect3d(const Geometry &g, const Parameter &p1, const Parameter &p2)

apply a reflection 3d on a Geometry (2 keys) (template external)

inline Geometry xlifepp::reflect3d(const Geometry &g, const Point &c, real_t nx, real_t ny, real_t nz = 0.)

apply a reflection 3d on a Geometry (template external)

inline Geometry xlifepp::reflect3d(const Geometry &g, const Point &c = Point(0., 0., 0.), std::vector<real_t> n = std::vector<real_t>(3, 0.))

apply a reflection 3d on a Geometry (template external)

Mesh xlifepp::reflect3d(const Mesh &m, const Parameter &p1)

apply a reflection3d on a Mesh (1 key)

apply a reflection 3D on a Mesh (1 key) (external)

Mesh xlifepp::reflect3d(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a reflection3d on a Mesh (2 keys)

apply a reflection 3D on a Mesh (2 keys) (external)

Mesh xlifepp::reflect3d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a reflection3d on a Mesh (3 keys)

apply a reflection 3D on a Mesh (3 keys) (external)

Mesh xlifepp::reflect3d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

apply a reflection3d on a Mesh (4 keys)

apply a reflection 3D on a Mesh (4 keys) (external)

Mesh xlifepp::reflect3d(const Mesh &m, const Point &c, real_t ux, real_t uy, real_t uz = 0.)

apply a reflection3d on a Mesh (external)

apply a reflection 3D on a Mesh (external)

Mesh xlifepp::reflect3d(const Mesh &m, const Point &c, std::vector<real_t> u = std::vector<real_t>(3, 0.))

apply a reflection3d on a Mesh (external)

apply a reflection 3D on a Mesh (external)

inline Point xlifepp::reflect3d(const Point &g, const Parameter &p1)

apply a reflection 3d on a Point (1 key) (template external)

inline Point xlifepp::reflect3d(const Point &g, const Parameter &p1, const Parameter &p2)

apply a reflection 3d on a Point (2 keys) (template external)

inline Point xlifepp::reflect3d(const Point &g, const Point &c, real_t nx, real_t ny, real_t nz = 0.)

apply a reflection 3d on a Point (template external)

inline Point xlifepp::reflect3d(const Point &g, const Point &c = Point(0., 0., 0.), std::vector<real_t> n = std::vector<real_t>(3, 0.))

apply a reflection 3d on a Point (template external)

RegularConeSphereTri

Mesh xlifepp::RegularConeSphereTri(const Point &C, const std::vector<real_t> &d, real_t hc, real_t rc, real_t apl, number_t ns, number_t nb, MeshGenerator mg = _subdiv, const std::vector<string_t> &domname = {"Omega"}, const string_t &edgename = "", const std::vector<string_t> &vertexnames = std::vector<string_t>(), bool namingSection = false)

create triangular mesh of a regular cone-sphere

release

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP>
inline void xlifepp::release(SmartPtr<T, OP, CP, KP, SP, CNP> &sp, typename SP<T>::StoredType &p)

removeChar

string_t &xlifepp::removeChar(string_t &s, char c)

remove all char c from string s

removeElts

void xlifepp::removeElts(std::set<GeomElement*> &elts, const std::set<number_t> &vSideCrack)

removeEndParenthesis

bool xlifepp::removeEndParenthesis(string_t &s)

removeMap

void xlifepp::removeMap(const GeomDomain&, const GeomDomain&)

remove map d1->d2

removePlusMinus

void xlifepp::removePlusMinus(string_t &s)

removeSmallValue

template<typename K>
void xlifepp::removeSmallValue(MatrixEigenDense<K> &mat)

removeZerosUmfPack

template<typename T>
void xlifepp::removeZerosUmfPack(std::vector<int_t> &colPointer, std::vector<int_t> &rowIndex, std::vector<T> &values)

renumber

std::vector<number_t> xlifepp::renumber(const Space *sp1, const Space *sp2)

renumber dofs of a space (sp2) along dof numbering of space (sp1) if the spaces are the same nothing is done: the result is of size 0 if the spaces are not the same: rn is the renumbering vector if sp2 is larger than sp1 : exemple sp1 = 8 4 5 1 4 7 6 sp2 = 3 5 7 4 rn = 0 3 6 5 0 means that 3 does not belong to sp1 3 means that 5 is the third element of sp1 … if sp1 is larger than sp2 : exemple sp1 = 4 3 6 8 sp2 = 1 2 3 4 5 6 7 8 9 rn = 0 0 2 1 0 3 0 8 0 0 means that 1,2,5, … does not belong to sp1 2 means that 3 is the second element of sp1 …

renumber dofs of a space along dof numbering of an another space

return sub-space or trace space on domain of a space, created if not exist

std::vector<number_t> xlifepp::renumber(const std::vector<DofComponent> &cdv1, const std::vector<DofComponent> &cdv2)

renumber cdofs vector (cdv2) along cdofs vector (cdv1) assuming cdof of cdv1 are unique if cdv1=cdv2 nothing is done: the result is of size 0 if cdv1!=cdv2 : rn is the renumbering vector ex: cdv1 = cd8 cd4 cd5 cd1 cd4 cd7 cd6 cdv2 = cd3 cd5 cd7 cd4 rn = 0 3 6 5 0 means that cd3 does not belong to cdv1 3 means that cd5 is the third cdofs of cdv1 …

renumbering cdofs utility

replaceChar

string_t &xlifepp::replaceChar(string_t &s, char c1, char c2)

replace all char c1 by char c2 in string s

replace char c1 by char c2 in string s

replaceString

string_t &xlifepp::replaceString(string_t &s, const string_t &s1, const string_t &s2)

replace all string s1 by string s2 in string s

replace string s1 by string s2 in string s

reset

template<typename T, template<class> class OP, class CP, template<class> class KP, template<class> class SP, template<class> class CNP>
inline void xlifepp::reset(SmartPtr<T, OP, CP, KP, SP, CNP> &sp, typename SP<T>::StoredType p)

resetThreadData

void xlifepp::resetThreadData()

resize

template<typename T>
void xlifepp::resize(Matrix<T> &v, dimen_t m, dimen_t n)

template<typename T>
void xlifepp::resize(std::vector<T> &v, dimen_t m, dimen_t n)

template<typename T>
void xlifepp::resize(T &v, dimen_t m, dimen_t n)

resizeThreadData

void xlifepp::resizeThreadData(number_t)

resize global vectors currentNxs, currentNys, …

reverseTriangleOrientation

void xlifepp::reverseTriangleOrientation(const std::vector<GeomElement*> &elements)

rhoExt

real_t xlifepp::rhoExt(real_t t, real_t a = 0.5)

rightPath

string_t xlifepp::rightPath(const string_t &path)

adapt path to OS format (WIN/LINUX like)

rk4

template<typename T>
Vector<T> xlifepp::rk4(T &(*f)(real_t, const T&, T&), real_t a, real_t b, real_t dt, const T &y0)

template<typename T, typename P>
Vector<T> xlifepp::rk4(T &(*f)(real_t, const T&, T&, P&), real_t a, real_t b, real_t dt, const T &y0, P &pars)

rot

OperatorOnUnknown &xlifepp::rot(const Unknown &un)

rot_x

OperatorOnKernel &xlifepp::rot_x(const Kernel&)

curl_x(k)

OperatorOnKernel &xlifepp::rot_x(OperatorOnKernel&)

curl_x(opk)

rot_y

OperatorOnKernel &xlifepp::rot_y(const Kernel&)

curl_y(k)

OperatorOnKernel &xlifepp::rot_y(OperatorOnKernel&)

curl_y(opk)

rotate2d

template<class Geom>
Geom xlifepp::rotate2d(const Geom &g, const Parameter &p1)

apply a rotation 2d on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::rotate2d(const Geom &g, const Parameter &p1, const Parameter &p2)

apply a rotation 2d on a Geom (2 keys) (template external)

template<class Geom>
Geom xlifepp::rotate2d(const Geom &g, const Point &c = Point(0., 0.), real_t angle = 0.)

apply a rotation 2d on a Geom (template external)

inline Geometry xlifepp::rotate2d(const Geometry &g, const Parameter &p1)

apply a rotation 2d on a Geometry (1 key) (template external)

inline Geometry xlifepp::rotate2d(const Geometry &g, const Parameter &p1, const Parameter &p2)

apply a rotation 2d on a Geometry (2 keys) (template external)

inline Geometry xlifepp::rotate2d(const Geometry &g, const Point &c = Point(0., 0.), real_t angle = 0.)

apply a rotation 2d on a Geometry (template external)

Mesh xlifepp::rotate2d(const Mesh &m, const Parameter &p1)

apply a rotation on a Mesh (1 key)

apply a rotation 2D on a Mesh (1 key) (external)

Mesh xlifepp::rotate2d(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a rotation on a Mesh (2 keys)

apply a rotation 2D on a Mesh (2 keys) (external)

Mesh xlifepp::rotate2d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a rotation on a Mesh (3 keys)

apply a rotation 2D on a Mesh (3 keys) (external)

Mesh xlifepp::rotate2d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

apply a rotation on a Mesh (4 keys)

apply a rotation 2D on a Mesh (4 keys) (external)

Mesh xlifepp::rotate2d(const Mesh &m, const Point &c, real_t angle = 0.)

apply a rotation on a Mesh (external)

apply a rotation 2D on a Mesh (external)

inline Point xlifepp::rotate2d(const Point &g, const Parameter &p1)

apply a rotation 2d on a Point (1 key) (template external)

inline Point xlifepp::rotate2d(const Point &g, const Parameter &p1, const Parameter &p2)

apply a rotation 2d on a Point (2 keys) (template external)

inline Point xlifepp::rotate2d(const Point &g, const Point &c = Point(0., 0.), real_t angle = 0.)

apply a rotation 2d on a Point (template external)

rotate3d

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, const Parameter &p1)

apply a rotation 3d on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, const Parameter &p1, const Parameter &p2)

apply a rotation 3d on a Geom (2 keys) (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a rotation 3d on a Geom (3 keys) (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, const Point &c, real_t dx, real_t dy, real_t angle)

apply a rotation 3d on a Geom (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, const Point &c, real_t dx, real_t dy, real_t dz, real_t angle)

apply a rotation 3d on a Geom (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, const Point &c = Point(0., 0., 0.), std::vector<real_t> d = std::vector<real_t>(3, 0.), real_t angle = 0.)

apply a rotation 3d on a Geom (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, real_t dx, real_t dy, real_t angle)

apply a rotation 3d on a Geom (template external)

template<class Geom>
Geom xlifepp::rotate3d(const Geom &g, real_t dx, real_t dy, real_t dz, real_t angle)

apply a rotation 3d on a Geom (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, const Parameter &p1)

apply a rotation 3d on a Geometry (1 key) (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, const Parameter &p1, const Parameter &p2)

apply a rotation 3d on a Geometry (2 keys) (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a rotation 3d on a Geometry (3 keys) (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, const Point &c, real_t dx, real_t dy, real_t angle)

apply a rotation 3d on a Geometry (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, const Point &c, real_t dx, real_t dy, real_t dz, real_t angle)

apply a rotation 3d on a Geometry (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, const Point &c = Point(0., 0., 0.), std::vector<real_t> d = std::vector<real_t>(3, 0.), real_t angle = 0.)

apply a rotation 3d on a Geometry (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, real_t dx, real_t dy, real_t angle)

apply a rotation 3d on a Geometry (template external)

inline Geometry xlifepp::rotate3d(const Geometry &g, real_t dx, real_t dy, real_t dz, real_t angle)

apply a rotation 3d on a Geometry (template external)

Mesh xlifepp::rotate3d(const Mesh &m, const Parameter &p1)

apply a rotation on a Mesh (1 key)

apply a rotation 3D on a Mesh (4 keys) (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a rotation on a Mesh (2 keys)

apply a rotation 3D on a Mesh (4 keys) (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a rotation on a Mesh (3 keys)

apply a rotation 3D on a Mesh (4 keys) (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

apply a rotation on a Mesh (4 keys)

apply a rotation 3D on a Mesh (4 keys) (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)

apply a rotation on a Mesh (5 keys)

apply a rotation 3D on a Mesh (4 keys) (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Point &c, real_t ux, real_t uy, real_t angle)

apply a rotation on a Mesh (external)

apply a rotation 3D on a Mesh (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Point &c, real_t ux, real_t uy, real_t uz, real_t angle)

apply a rotation on a Mesh (external)

apply a rotation 3D on a Mesh (external)

Mesh xlifepp::rotate3d(const Mesh &m, const Point &c, std::vector<real_t> u = std::vector<real_t>(3, 0.), real_t angle = 0.)

apply a rotation on a Mesh (external)

apply a rotation 3D on a Mesh (external)

Mesh xlifepp::rotate3d(const Mesh &m, real_t ux, real_t uy, real_t angle)

apply a rotation on a Mesh (external)

apply a rotation 3D on a Mesh (external)

Mesh xlifepp::rotate3d(const Mesh &m, real_t ux, real_t uy, real_t uz, real_t angle)

apply a rotation on a Mesh (external)

apply a rotation 3D on a Mesh (external)

inline Point xlifepp::rotate3d(const Point &g, const Parameter &p1)

apply a rotation 3d on a Point (1 key) (template external)

inline Point xlifepp::rotate3d(const Point &g, const Parameter &p1, const Parameter &p2)

apply a rotation 3d on a Point (2 keys) (template external)

inline Point xlifepp::rotate3d(const Point &g, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a rotation 3d on a Point (3 keys) (template external)

inline Point xlifepp::rotate3d(const Point &g, const Point &c, real_t dx, real_t dy, real_t angle)

apply a rotation 3d on a Point (template external)

inline Point xlifepp::rotate3d(const Point &g, const Point &c, real_t dx, real_t dy, real_t dz, real_t angle)

apply a rotation 3d on a Point (template external)

inline Point xlifepp::rotate3d(const Point &g, const Point &c = Point(0., 0., 0.), std::vector<real_t> d = std::vector<real_t>(3, 0.), real_t angle = 0.)

apply a rotation 3d on a Point (template external)

inline Point xlifepp::rotate3d(const Point &g, real_t dx, real_t dy, real_t angle)

apply a rotation 3d on a Point (template external)

inline Point xlifepp::rotate3d(const Point &g, real_t dx, real_t dy, real_t dz, real_t angle)

apply a rotation 3d on a Point (template external)

rotG

OperatorOnUnknown &xlifepp::rotG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)

rotS

OperatorOnUnknown &xlifepp::rotS(const Unknown &un)

round

inline complex_t xlifepp::round(const complex_t &z, real_t prec)

inline real_t xlifepp::round(const real_t &x, real_t prec)

template<typename T>
std::list<T> xlifepp::round(const std::list<T> &l, real_t prec)

template<typename K, typename T>
std::map<K, T> xlifepp::round(const std::map<K, T> &m, real_t prec)

template<typename T>
std::vector<T> xlifepp::round(const std::vector<T> &v, real_t prec)

template<typename T>
const T &xlifepp::round(const T &t, real_t prec)

template<typename T>
int_t xlifepp::round(const T &v)

round to nearest integer

template<typename T>
Vector<T> xlifepp::round(const Vector<T> &v, real_t prec)

template<typename Iterator>
void xlifepp::round(Iterator itb, Iterator ite, Iterator rt, real_t prec)

roundToZero

inline complex_t xlifepp::roundToZero(const complex_t &v, real_t asZero = std::sqrt(theEpsilon))

inline real_t xlifepp::roundToZero(const real_t &v, real_t asZero = std::sqrt(theEpsilon))

round to zero for scalars

template<typename T>
std::vector<T> xlifepp::roundToZero(const std::vector<T> &v, real_t asZero = std::sqrt(theEpsilon))

round to zero for vectors

TermMatrix xlifepp::roundToZero(const TermMatrix &tm, real_t aszero = 10 * theEpsilon)

return the 0 rounded TermMatrix)

return the 0 rounded TermMatrix

template<typename T>
Vector<T> xlifepp::roundToZero(const Vector<T> &v, real_t asZero = std::sqrt(theEpsilon))

rsvd

template<typename T>
LowRankMatrix<T> &xlifepp::rsvd(const LargeMatrix<T> &lm, LowRankMatrix<T> &lrm, number_t r = 0, real_t eps = theTolerance)

rsvd of a LargeMatrix

RSVD compression method of a LargeMatrix to a LowRankMatrix Lr T: type of the result lm: LargeMatrix to be compressed r: prescribed rank of truncature, if 0 not used, the real rank at output eps: prescribed precision, if rk > 0 not used r=0 and eps=0 gives the full svd lrm: LowRankMatrix.

template<typename M, typename T>
void xlifepp::rsvd(M &A, number_t r, std::vector<T> &U, std::vector<T> &D, std::vector<T> &V)

Random SVD compression method of a matrix of class M T: type of the result A: matrix of class M, requires the member functions: M::numberOfRows(), M::numberOfCols() M::multMatrixRow(T* M, T* R, number_t p) i.e M*matRow M::multLeftMatrixRow(T* M, T* R, number_t p) i.e matRow*M r: prescribed rank >0 of truncature U, V: vectors storing dense row matrices S: vector storing S.

template<typename M, typename T>
void xlifepp::rsvd(M &A, real_t eps, number_t &rk, std::vector<T> &U, std::vector<T> &D, std::vector<T> &V)

Random SVD compression method of a matrix of class M from the paper: Stephanie Chaillat, George Biros.

FaIMS: A fast algorithm for the inverse medium problem with multiple frequencies and multiple sources for the scalar Helmholtz equation. Journal of Computational Physics, Elsevier, 2012, 231 (12), pp.4403-4421. T: type of the result A: matrix of class M, requires the member functions: M::numberOfRows(), M::numberOfCols() M::multMatrixRow(T* M, T* R, number_t p) i.e M*matRow M::multLeftMatrixRow(T* M, T* R, number_t p) i.e matRow*M eps: desired precision for the SVD matrix rk: rank of rsvd on output U, V: vectors storing dense row matrices S: vector storing S

template<typename T>
void xlifepp::rsvd(Matrix<T> &A, Matrix<T> &U, Vector<T> &D, Matrix<T> &V, number_t r = 0, real_t eps = theTolerance)

Random SVD with either rank or precision truncation T: type of the matrix (real or complex) A: Matrix to be be factorized U,D,V: SVD factors A~U*D*V’ (output) r: prescribed rank eps: energy threshold if r > 0, the SVD is restricted to the first r singular values else it is restricted to the first singular values smaller than eps.

template<typename T>
void xlifepp::rsvd(T *A, number_t m, number_t n, number_t r, T *U, T *D, T *V)

Random SVD compression method of a row dense matrix given by pointer T: type of the result A: pointer to the first element of the dense matrix to be compressed, stored as row major access (dense row) m, n: number of rows and cols of matrix to be compressed r: prescribed rank >0 of truncature U, V: pointer to dense row matrices, has to be allocated before S: pointer to S vector, has to be allocated before.

note: may be used when A is a pointer to a m x n col dense matrix, by permuting arguments when calling: rsvd(A,n,m,rk,V,D,U) produces the RSVD of A = U*D*V’ where U, V are pointers to row dense matrices!

template<typename T>
void xlifepp::rsvd(T *A, number_t m, number_t n, real_t eps, number_t &rk, T *U, T *D, T *V)

Random SVD compression method of a row dense matrix given by pointer from the paper: Stephanie Chaillat, George Biros.

FaIMS: A fast algorithm for the inverse medium problem with multiple frequencies and multiple sources for the scalar Helmholtz equation. Journal of Computational Physics, Elsevier, 2012, 231 (12), pp.4403-4421. T: type of the result A: pointer to the first element of the dense matrix to be compressed, stored as row major access (dense row) m, n: number of rows and cols of matrix to be compressed eps: desired precision for the SVD matrix rk: rank of rsvd on output U, V: pointer to dense row matrices, has to be allocated before S: pointer to S vector, has to be allocated before

note: may be used when A is a pointer to a m x n col dense matrix, by permuting arguments when calling: rsvd(A,n,m,eps,V,D,U) produces the RSVD of A = U*D*V’ where U, V are pointers to row dense matrices!

ruledSurfaceFrom

inline Geometry xlifepp::ruledSurfaceFrom(const Geometry &c, string_t domName = "")

definition of a geometry 2D from an union of boundaries 1D

sameDofs

bool xlifepp::sameDofs(const SuTermVector&, const SuTermVector&)

tensor cross product => vector SuTermVector in 3D, scalar SuTermVector in 2D

check if 2 SuTermVector have same dofs

sameOrientation

bool xlifepp::sameOrientation(std::vector<const Point*> border1, std::vector<const Point*> border2)

determine if 2 lists of points ordered differently have the same orientation It is supposed that every point in each list is also in the other one

determine if 2 geometries (list of vertices) have the same orientation

sameStorage

bool xlifepp::sameStorage(const MatrixStorage &sto1, const MatrixStorage &sto2)

compare two storages, they are same if all the coefficients are travelled in the same way

test if two storages are similar

• storage pointers are the same

• storage types are the same, sizes are the same and storage structure are the same

saveCircArcToGeo

void xlifepp::saveCircArcToGeo(CircArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)

writing a circle arc in a geo file

saveComponentExtraDataToGeo

void xlifepp::saveComponentExtraDataToGeo(const Geometry &g, number_t nloops, std::ofstream &fout)

writing the surface/volume definition (Plane Surface or Volume command in geo)

saveComponentToGeo

void xlifepp::saveComponentToGeo(Geometry &g, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a component of composite geometry in a geo file whatever the dimension

saveConeToGeo

void xlifepp::saveConeToGeo(Cone &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a conical volume in a geo file

writing a cone in a geo file

saveCylinderToGeo

void xlifepp::saveCylinderToGeo(Cylinder &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a cylindrical volume in a geo file

saveDiskToGeo

void xlifepp::saveDiskToGeo(Disk &d, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)

writing a disk in a geo file

saveEllArcToGeo

void xlifepp::saveEllArcToGeo(EllArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)

writing an elliptic arc in a geo file

saveEllipseToGeo

void xlifepp::saveEllipseToGeo(Ellipse &e, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)

writing an elliptic surface in a geo file

saveEllipsoidToGeo

void xlifepp::saveEllipsoidToGeo(Ellipsoid &e, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing an ellipsoidal volume or a ball in a geo file

saveExtByCompositionToGeo

void xlifepp::saveExtByCompositionToGeo(const Geometry &g, const Transformation &t, std::ofstream &fout, const std::map<string_t, Strings> &inputs)

writing an extrusion by a composition of translations and rotations in a geo file

saveExtByRotation2dToGeo

void xlifepp::saveExtByRotation2dToGeo(const Geometry &g, const Rotation2d &r, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)

writing an extrusion by Rotation2d in a geo file

saveExtByRotation3dToGeo

void xlifepp::saveExtByRotation3dToGeo(const Geometry &g, const Rotation3d &r, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)

writing an extrusion by Rotation3d in a geo file

saveExtByRotationSideNamesToGeo

void xlifepp::saveExtByRotationSideNamesToGeo(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const real_t angle, std::ofstream &fout, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids)

writing sidenames of an extrusion by Rotation2d in a geo file

writing sidenames of an extrusion by Rotation2d or Rotation3d in a geo file

saveExtByTranslationSideNamesToGeo

void xlifepp::saveExtByTranslationSideNamesToGeo(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const Translation &t, std::ofstream &fout, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids)

writing sidenames of an extrusion by Translation in a geo file

saveExtByTranslationToGeo

void xlifepp::saveExtByTranslationToGeo(const Geometry &g, const Translation &t, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)

writing an extrusion by Translation in a geo file

saveExtrusionComponentToGeo

void xlifepp::saveExtrusionComponentToGeo(const Geometry &g, const Transformation &t, std::vector<int_t> nnodesPerLine, std::ofstream &fout, const std::map<string_t, Strings> &inputs)

writing an extrusion in a geo file

saveExtrusionGeometryToGeo

std::vector<std::pair<number_t, number_t>> xlifepp::saveExtrusionGeometryToGeo(Geometry &g, ShapeType sh, real_t angle, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)

writing an extrusion geometry in a geo file whatever the dimension

saveExtrusionInputsAsString

string_t xlifepp::saveExtrusionInputsAsString(const std::map<string_t, Strings> &inputs)

writing extrusion inputs as string

saveExtrusionSideNamesToGeo

void xlifepp::saveExtrusionSideNamesToGeo(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const Transformation &t, std::ofstream &fout, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids)

writing sidenames of an extrusion in a geo file

saveHexahedronToGeo

void xlifepp::saveHexahedronToGeo(Hexahedron &h, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a hexahedron in a geo file

saveParallelepipedToGeo

void xlifepp::saveParallelepipedToGeo(Parallelepiped &p, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a parallelepiped, a cuboid or a cube in a geo file

saveParametrizedArcToGeo

void xlifepp::saveParametrizedArcToGeo(ParametrizedArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)

writing a parametrized arc in a geo file

saveParametrizedSurfaceToGeo

void xlifepp::saveParametrizedSurfaceToGeo(ParametrizedSurface &s, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)

writing a parametrized surface (split in triangle or nurbs) in a geo file split the parametrized surface s in s.nbParts elementary surface either quadrangle or triangle or nurbs (s.shapePart)

writing a parametrized surface in a geo file

savePolygonToGeo

void xlifepp::savePolygonToGeo(Polygon &p, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)

writing a triangle in a geo file

writing a polygon in a geo file

savePolyhedronToGeo

void xlifepp::savePolyhedronToGeo(Polyhedron &p, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a polyhedral volume in a geo file

writing a polyhedron in a geo file

saveQuadrangleToGeo

void xlifepp::saveQuadrangleToGeo(Quadrangle &q, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)

writing a quadrangle, a rectangle or a square in a geo file

saveRevConeToGeo

void xlifepp::saveRevConeToGeo(RevCone &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a revolution conical volume in a geo file

writing a revolution cone in a geo file

saveRevCylinderToGeo

void xlifepp::saveRevCylinderToGeo(RevCylinder &c, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a prism in a geo file

writing a revolution cylindrical volume in a geo file

saveRevTrunkToGeo

void xlifepp::saveRevTrunkToGeo(RevTrunk &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a prism in a geo file

writing a revolution trunk in a geo file

saveSegmentToGeo

void xlifepp::saveSegmentToGeo(Segment &s, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)

writing a segment in a geo file

saveSplineArcToGeo

void xlifepp::saveSplineArcToGeo(const SplineArc &a, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withSideNames)

writing a spline arc in a geo file spline in standard gmsh factory corresponds to Catmull-Rom spline spline in occ gmsh factory corresponds to C2 spline

writing a parametrized arc in a geo file

saveTetrahedronToGeo

void xlifepp::saveTetrahedronToGeo(Tetrahedron &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a tetrahedron in a geo file

saveToBrepGeo

void xlifepp::saveToBrepGeo(Geometry &g, MeshData &meshData, ShapeType sh, number_t order, MeshPattern pattern, StructuredMeshSplitPattern splitPattern, const string_t &geofile, const string_t &brepfile)

writing a 2D/3D geometry in a geo file using Open Cascade way and Brep format

saveToFile

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs)

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const Parameter &p1)

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const Parameter &p1, const Parameter &p2)

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, const std::vector<Parameter> &ps)

save eigenvalues into one file and eigenvectors into separate files

inline void xlifepp::saveToFile(const string_t &filename, const EigenElements &evs, IOFormat iof)

void xlifepp::saveToFile(const string_t &filename, const GeomDomain &dom, IOFormat iof)

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m)

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1)

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1, const Parameter &p2)

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

inline void xlifepp::saveToFile(const string_t &filename, const Mesh &m, IOFormat iof, bool withDomains = false)

void xlifepp::saveToFile(const string_t &filename, const Space *sp, const list<SuTermVector*> &sutvs, IOFormat iof, bool withElementSplitting, string_t dataName, bool aFilePerDomain)

save a list of SuTermVectors on a same Space to files

input/output function

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs)

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1)

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1, const Parameter &p2)

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1, const Parameter &p2, const Parameter &p3)

inline void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

void xlifepp::saveToFile(const string_t &filename, const std::list<const TermVector*> &tvs, const std::vector<Parameter> &ps)

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs)

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const Parameter &p1)

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const Parameter &p1, const Parameter &p2)

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, const std::vector<Parameter> &ps)

save singular values into one file and singular vectors into separate files

inline void xlifepp::saveToFile(const string_t &filename, const SvdElements &evs, IOFormat iof)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A)

save TermMatrix to file (dense or Matlab format)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A, const Parameter &p1)

save TermMatrix to file (dense or Matlab format)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A, const Parameter &p1, const Parameter &p2)

save TermMatrix to file (dense or Matlab format)

inline void xlifepp::saveToFile(const string_t &filename, const TermMatrix &A, StorageType st, bool enc = false)

save TermMatrix to file (dense or Matlab format)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv)

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, bool aFilePerDomain)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1, const Parameter &p2)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, IOFormat iof, bool aFilePerDomain = true)

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv, string_t dataName, bool aFilePerDomain = true)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2)

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, bool aFilePerDomain)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1, const Parameter &p2)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3)

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, bool aFilePerDomain)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1, const Parameter &p2)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4)

inline void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, bool aFilePerDomain)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1, const Parameter &p2)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs)

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, bool aFilePerDomain)

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const Parameter &p1)

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const Parameter &p1, const Parameter &p2)

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const Parameter &p1, const Parameter &p2, const Parameter &p3)

void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, const std::vector<Parameter> &ps)

save TermVectors to files

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, IOFormat iof, bool aFilePerDomain = false)

inline void xlifepp::saveToFile(const string_t &filename, const TermVectors &tvs, string_t dataName = "", bool aFilePerDomain = false)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv, const string_t &dataName, IOFormat format, bool aFilePerDomain)

save 1 TermVector to files with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, IOFormat format, bool aFilePerDomain)

save 4 TermVector to filesc01;nC110404 with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, const TermVector &tv4, string_t dataName, bool aFilePerDomain)

save 4 TermVectors to files with a specific data name (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, IOFormat format, bool aFilePerDomain)

save 3 TermVector to files with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, const TermVector &tv3, string_t dataName, bool aFilePerDomain)

save 3 TermVectors to files with a specific data name (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, IOFormat format, bool aFilePerDomain)

save 2 TermVector to files with a specific format (alias of the version with a list of TermVectors)

void xlifepp::saveToFile(const string_t &fn, const TermVector &tv1, const TermVector &tv2, string_t dataName, bool aFilePerDomain)

save 2 TermVectors to files with a specific data name (alias of the version with a list of TermVectors)

saveToGeo

void xlifepp::saveToGeo(Geometry &g, MeshData &meshData, number_t order, const string_t &filename)

writing a 1D geometry in a geo file

void xlifepp::saveToGeo(Geometry &g, MeshData &meshData, ShapeType sh, number_t order, MeshPattern pattern, StructuredMeshSplitPattern splitPattern, const string_t &filename, std::set<CrackData> &cracks)

writing a 2D/3D geometry in a geo file

saveToMsh

void xlifepp::saveToMsh(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)

save a list of SuTermVectors on the same Space to msh files

void xlifepp::saveToMsh(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")

saveToMtlb

void xlifepp::saveToMtlb(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)

save a list of SuTermVectors on the same Space to Matlab - Octave files

void xlifepp::saveToMtlb(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")

saveToVizir4

void xlifepp::saveToVizir4(ostream &fout, ostream &gout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, bool withElementSplitting, string_t dataName)

save a list of SuTermVectors on the same Space to vtk xml files for unstructured grid type meshes

void xlifepp::saveToVizir4(std::ostream &fout, std::ostream &gout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, bool withElementSplitting, string_t dataName)

saveToVtk

void xlifepp::saveToVtk(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)

save a list of SuTermVectors on the same Space to vtk files

void xlifepp::saveToVtk(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")

saveToVtkVtu

void xlifepp::saveToVtkVtu(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, const GeomDomain *dom, string_t dataName)

save a list of SuTermVectors on the same Space to vtk xml files for unstructured grid type meshes

void xlifepp::saveToVtkVtu(std::ostream &fout, const Space*, const std::list<SuTermVector*>&, const std::vector<Point> &coords, const splitvec_t &elementsInfo, const GeomDomain *dom, string_t dataName = "")

saveToXyzVs

void xlifepp::saveToXyzVs(ostream &fout, const Space *sp, const list<SuTermVector*> &sutvs, const vector<Point> &coords, string_t dataName, bool writeHeader)

save a list of SuTermVectors v’s on the same Space as raw file x [y [z]] v1 [v2 …] the ouput of coordinates depends of the dimension of mesh nodes when vi is a complex output vi.real vi.imag when vi is a real vector output vi_x vi_y [vi_z] when vi is a complex vector output vi_x.real vi_x.imag vi_y.real vi_y.imag [vi_z.real vi_z.imag]

saveTriangleToGeo

void xlifepp::saveTriangleToGeo(Triangle &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withEdgeNames, bool withVertexNames)

writing a triangle in a geo file

saveTrunkToGeo

void xlifepp::saveTrunkToGeo(Trunk &t, ShapeType sh, std::ofstream &fout, std::vector<PhysicalData> &pids, bool withLoopsStorage, bool withFaceNames, bool withEdgeNames, bool withVertexNames)

writing a cylindrical volume in a geo file

writing a trunk in a geo file

scaledVectorTpl

template<typename scalar1, typename T1_iterator, typename R_iterator>
void xlifepp::scaledVectorTpl(const scalar1 &s, T1_iterator b1, T1_iterator e1, T1_iterator b2, R_iterator Rb)

Scaled vector R[i] = s * ( T1[i] - T2 [i] )

scaleVector

void xlifepp::scaleVector(const complex_t &k, const Vector<complex_t> &v, Vector<real_t> &r)

void xlifepp::scaleVector(const complex_t &k, const Vector<real_t> &v, Vector<real_t> &r)

template<typename K, typename K1, typename K2>
void xlifepp::scaleVector(const K &k, const Vector<K1> &v, Vector<K2> &r)

void xlifepp::scaleVector(const real_t &k, const Vector<complex_t> &v, Vector<real_t> &r)

scatteredFieldDiskDirichlet

complex_t xlifepp::scatteredFieldDiskDirichlet(const Point &p, Parameters &param)

Exact solution to the Helmholtz 2D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*K*x}).

‘Exact solutions’ to the Helmholtz 2D problem outside a disk

Field scattered by solid disk of radius Rad of an incoming field Phi_w= exp^{(i*k*x}).

with Dirichlet boundary condition on the sphere

scatteredFieldDiskDirichlet_dr

complex_t xlifepp::scatteredFieldDiskDirichlet_dr(const Point&, Parameters&)

scatteredFieldDiskNeumann

complex_t xlifepp::scatteredFieldDiskNeumann(const Point&, Parameters&)

scatteredFieldMaxwellExn

Vector<complex_t> xlifepp::scatteredFieldMaxwellExn(const Point &p, Parameters &param)

Exact solution to the Maxwell 3D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming vector field Phi_w= (1,0,0)*exp^{(i*K*z}).

‘Exact solutions’ to the Maxwell 3D problem outside a sphere

Field scattered by solid sphere of radius R of an incoming field Phi_w= exp^{(i*k*z}). with tangential boundary condition Exn = 0 (electric field) on the sphere:

\(\Phi(\rho,\theta \phi) = \sum_{n=1..\infty} i^n * (2n+1) * cos\phi*e_rho*c_rho[n] + cos\phi*e_theta*c_theta[n] + sin\phi*c_phi[n]\)

with

• [ \(\sin\theta*\cos\phi\) ] [ \(\cos\theta*\cos\phi\) ] [ \(-\sin\phi\) ]

• e_rho =[ \(\sin\theta*\sin\phi\) ] e_theta =[ \(\cos\theta*\sin\phi\) ] e_phi =[ \(\cos\phi\) ]

• [ \(\cos\theta\) ] [ \(-\sin\theta\) ] [ 0 ] and

• \(c_rho[n] = - A_n(K*R) * H_{n}(K*rho)/K*rho ) * Ps_n(\cos\theta)\)

• c_theta[n] =

• c–phi[n] =

where

• A_n(r) = -i^{n-1} (2*n+1) real(hnp(r)) / hnp(r) where hnp(r) = d/dr[H_{n}](r) + H_{n}(r)

• B_n(r) = -i^{n-1} (2*n+1) real(H_{n}(r)) / H_{n}(r) and

• H_{n} = h_n^{(1)} = j_n + i*y_n is the spherical hankel function of first kind and order n

• j_n: spherical bessel function of the first kind and order n

• y_n: spherical bessel function of the second kind and order n

with electric field boundary condition Exn=0 on the sphere

Some computed values for K=1 X_1 X_2 X_3 Phi_1 Phi_2 Phi_3 1.0 0.0 0.0 | (1.75532926384 , 1.62107824182 ) (0 , 0 ) (-6.02796306309e-18,-1.58122117268e-18) 0.0 1.0 0.0 | (-1 , 4.81409564708e-17) (0 , 0 ) (0 , 0 ) 0.0 0.0 1.0 | (-5.40302305868e-01,-8.41470984808e-01) (0 , 0 ) (0 , 0 ) 1.0 1.0 1.0 | (-1.69184878965e-01, 1.61131192686e-01) (2.06589901137e-01, 2.52914553648e-01) (1.19848010392e-01, 3.28542217311e-01) 1.0 1.0 1.2 | (-1.86022424304e-01, 9.18508880491e-02) (1.49911272089e-01, 2.01342400004e-01) (9.37804387189e-02, 3.03355869671e-01) 1.0 1.0 1.4 | (-1.91775499206e-01, 3.34280295554e-02) (1.07142066815e-01, 1.59632591445e-01) (6.64556013889e-02, 2.71335010720e-01) 1.0 1.0 1.6 | (-1.88260942630e-01,-1.51180741005e-02) (7.54265673653e-02, 1.27220194457e-01) (4.11641109484e-02, 2.38176631400e-01) 1.0 1.0 1.8 | (-1.77261848423e-01,-5.51624601093e-02) (5.20175373132e-02, 1.02356587880e-01) (1.91974583103e-02, 2.06737287161e-01) 1.0 1.0 2.0 | (-1.60341338903e-01,-8.78244555191e-02) (3.47085585869e-02, 8.32071602821e-02) (8.24999561215e-04, 1.78106610047e-01) 1.2 1.4 1.0 | (-1.93790114095e-01, 7.12577504506e-02) (1.44884948487e-01, 2.06529528004e-01) (1.39532076671e-02, 1.97067304047e-01) 1.2 1.4 1.2 | (-1.90729686988e-01, 2.88712762800e-02) (1.12819966807e-01, 1.81439122245e-01) (9.10642428927e-03, 1.94073277948e-01) 1.2 1.4 1.4 | (-1.83137187727e-01,-1.04437244804e-02) (8.50160197427e-02, 1.57350273961e-01) (7.19355647585e-04, 1.84905785693e-01) 1.2 1.4 1.6 | (-1.70990951385e-01,-4.55518271208e-02) (6.17400731503e-02, 1.35416184077e-01) (-9.27523672141e-03, 1.71746716026e-01) 1.2 1.4 1.8 | (-1.54657449587e-01,-7.58575264387e-02) (4.27052811485e-02, 1.16028225273e-01) (-1.95184324637e-02, 1.56344795623e-01) 1.2 1.4 2.0 | (-1.34728108413e-01,-1.01074590219e-01) (2.73910156223e-02, 9.91350581457e-02) (-2.91430511034e-02, 1.39939464554e-01)

scatteredFieldSphereDirichlet

complex_t xlifepp::scatteredFieldSphereDirichlet(const Point&, Parameters&)

Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*k*x}).

Exact solution to the Helmholtz 3D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*K*x}).

with Dirichlet boundary condition on the sphere: Series representation of Bessel spherical functions and Legendre polynomials

\(\Phi(\rho,\phi) = \sum_{n=0}^\infty A\_n(K*Rad) h_n^{(1)}(K*\rho) P_n(cos(\phi))\)

where \(A_n(r) = i^n (2*n+1) { j_n(kR)/ h_n^{(1)}(kR)}\)

with Dirichlet boundary condition on the sphere

scatteredFieldSphereNeumann

complex_t xlifepp::scatteredFieldSphereNeumann(const Point &p, Parameters &param)

Exact solution to the Helmholtz 3D problem outside a sphere: Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*K*x}).

‘Exact solutions’ to the Helmholtz 3D problem outside a sphere

Field scattered by solid sphere of radius Rad of an incoming field Phi_w= exp^{(i*k*x}). with Neumann boundary condition on the sphere: Series representation of Bessel spherical functions and Legendre polynomials

\(\Phi(\rho,\phi) = \sum_{n=0}^\infty A\_n(K*Rad) h_n^{(1)}(K*\rho) P_n(cos(\phi))\)

where \(A_n(r) = - i^n (2*n+1) { d/dr[j_n](r) / d/dr[h_n^{(1)}](r) }\) and

• h_n^{(1)} = H_{n} = j_n + i*y_n is the spherical hankel function of first kind and order n

• j_n: spherical bessel function of the first kind and order n

• y_n: spherical bessel function of the second kind and order n

&#8212; for spherical Bessel functions, see

• HANDBOOK Of MATHEMATICAL FUNCTIONS, Ed. M.ABRAMOWITZ & I.A. STEGUN

• Chap. 10 : Bessel Functions of Fractional Order (p.437-494)

• http://www.math.sfu.ca/~cbm/aands/page_437.htm &#8212; for Legendre polynomials, see

• http://en.wikipedia.org/wiki/Legendre_polynomials

with Neumann boundary condition on the sphere

schurSolve

TermVector xlifepp::schurSolve(TermMatrix &A, const TermVector &B, const Unknown &row_v, const Unknown &col_u, bool keepA)

Schur Solver, only for 2x2 unknowns TermMatrix:

|A11  A12 ||X1|   |B1|
|         ||  | = |  |
|A21  A22 ||X2|   |B1|

if A11 is invertible: C21 = A21 * inv(A11) * A12 C22 = A22 - C21 D2 = B2 - A21 * inv(A11) * B1 if C22 invertible X2 = inv(C22) * D2 X1 = inv(A11)(B1 - A12 * X2)

A: multiple unknowns TermMatrix B: multiple unknowns TermVector row_v, col_u: unknowns pair defining the diagonal block used as pivot (say A11) keepA: true if TermMatrix has to be preserved (TermVector B is always preserved)

securedPath

string_t xlifepp::securedPath(const string_t &path)

adapt path to OS format and check if path exists

segmentQuadrature

Quadrature *xlifepp::segmentQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit segment

selectRefHexahedron

RefElement *xlifepp::selectRefHexahedron(const Interpolation *int_p)

selectRefHexahedron construction of a Reference Element by interpolation type and interpolation subtype

selectRefPrism

RefElement *xlifepp::selectRefPrism(const Interpolation *interp_p)

selectRefPrism construction of a prismatic Reference Element by interpolation subtype and number

selectRefPyramid

RefElement *xlifepp::selectRefPyramid(const Interpolation *interp_p)

selectRefPyramid construction of a pyramidatic Reference Element by interpolation subtype and number

selectRefQuadrangle

RefElement *xlifepp::selectRefQuadrangle(const Interpolation *interp_p)

selectRefQuadrangle construction of a Reference Element by interpolation type and interpolation subtype

selectRefSegment

RefElement *xlifepp::selectRefSegment(const Interpolation *interp_p)

segment construction of a 1D Reference Element by interpolation type and interpolation subtype

selectRefTetrahedron

RefElement *xlifepp::selectRefTetrahedron(const Interpolation *interp_p)

tetrahedronConstructor construction of a Reference Element by interpolation type and interpolation subtype

selectRefTriangle

RefElement *xlifepp::selectRefTriangle(const Interpolation *interp_p)

selectReferenceTriangle construction of a Reference Element by interpolation type and interpolation subtype

setB

inline void xlifepp::setB(Vector<real_t> &p)

inline void xlifepp::setB(Vector<real_t> *p, number_t t)

setBasisIndex

inline void xlifepp::setBasisIndex(number_t i)

inline void xlifepp::setBasisIndex(number_t i, number_t t)

setBx

inline void xlifepp::setBx(Vector<real_t> &p)

inline void xlifepp::setBx(Vector<real_t> *p)

inline void xlifepp::setBx(Vector<real_t> *p, number_t t)

setBy

inline void xlifepp::setBy(Vector<real_t> &p)

inline void xlifepp::setBy(Vector<real_t> *p)

inline void xlifepp::setBy(Vector<real_t> *p, number_t t)

setColor

void xlifepp::setColor(const GeomDomain &dom, const TermVector &tv, ColoringRule cr)

set color of geom elements of domain according to vertex values and a coloring rule dom: the domain to colorize val: a single unknown TermVector containing the values used to colorize cr: the ColoringRule, i.e.

set color of geom elements of domain according to vertex values and a coloring rule

a function of the form: real_t cr(const Geomelement& gelt, const std::vector<real_t>& v) returning the color of the geometric element (see defaultColoringRule function for instance)

void xlifepp::setColor(const GeomDomain &dom, const TermVector &tv, VectorColoringRule vcr)

set color of geom elements of domain according to vertex vector values and a vector coloring rule dom: the domain to colorize val: a single unknown TermVector containing the vector values used to colorize vcr: the vector ColoringRule, i.e.

set color of geom elements of domain according to vertex vector values and a vector coloring rule

a function of the form: real_t vcr(const Geomelement& gelt, const std::vector<Vector<real_t> >& v) returning the color of the geometric element (see defaultColoringRule function for instance)

void xlifepp::setColor(const GeomDomain &dom, real_t r)

set the color of geom elements to r value

setDefaultCharacteristicLength

inline void xlifepp::setDefaultCharacteristicLength(real_t h)

set the characteristic length

setDerivative

inline void xlifepp::setDerivative(number_t i)

inline void xlifepp::setDerivative(number_t i, number_t t)

setDof

inline void xlifepp::setDof(Dof *p)

inline void xlifepp::setDof(Dof *p, number_t t)

setDomain

inline void xlifepp::setDomain(GeomDomain *p)

setDomainx

inline void xlifepp::setDomainx(GeomDomain *p)

setDomainy

inline void xlifepp::setDomainy(GeomDomain *p)

setElement

inline void xlifepp::setElement(GeomElement *p)

inline void xlifepp::setElement(GeomElement *p, number_t t)

seteol

inline void xlifepp::seteol(number_t n = 0)

manage eol variable by adding n spaces after carriage return

setGlobalVerboseLevel

void xlifepp::setGlobalVerboseLevel(const number_t)

set a maximum value for all verbose levels setGlobalVerboseLevel(0) sets all levels to zero

setN

inline void xlifepp::setN(Vector<real_t> &p)

inline void xlifepp::setN(Vector<real_t> *p, number_t t)

setNewHandler

void xlifepp::setNewHandler()

defines a new trace handler

setNx

inline void xlifepp::setNx(Vector<real_t> &p)

inline void xlifepp::setNx(Vector<real_t> *p)

inline void xlifepp::setNx(Vector<real_t> *p, number_t t)

setNy

inline void xlifepp::setNy(Vector<real_t> &p)

inline void xlifepp::setNy(Vector<real_t> *p)

inline void xlifepp::setNy(Vector<real_t> *p, number_t t)

setRanks

void xlifepp::setRanks(std::vector<Unknown*>&, const std::vector<number_t>&)

set ranks of unknowns

void xlifepp::setRanks(Unknown &u1, number_t r1)

void xlifepp::setRanks(Unknown &u1, number_t r1, Unknown &u2, number_t r2)

void xlifepp::setRanks(Unknown &u1, number_t r1, Unknown &u2, number_t r2, Unknown &u3, number_t r3)

void xlifepp::setRanks(Unknown &u1, number_t r1, Unknown &u2, number_t r2, Unknown &u3, number_t r3, Unknown &u4, number_t r4)

setRefCountedAlloc

template<typename T>
void xlifepp::setRefCountedAlloc(bool isAlloc, RefCounted<T> &ref)

setT

inline void xlifepp::setT(Vector<real_t> &p)

inline void xlifepp::setT(Vector<real_t> *p, number_t t)

setTx

inline void xlifepp::setTx(Vector<real_t> &p)

inline void xlifepp::setTx(Vector<real_t> *p)

inline void xlifepp::setTx(Vector<real_t> *p, number_t t)

setTy

inline void xlifepp::setTy(Vector<real_t> &p)

inline void xlifepp::setTy(Vector<real_t> *p)

inline void xlifepp::setTy(Vector<real_t> *p, number_t t)

shapeDim

int_t xlifepp::shapeDim(ShapeType sh)

dimension of a shape type (return -1 if not defined)

dimension of a shape type

shrink

template<typename T>
void xlifepp::shrink(std::vector<T> &u, number_t s)

resize and shrink a vector to size s

sides

GeomDomain &xlifepp::sides(GeomDomain &dom)

access to domain defined from all sides of elements of domain dom, create it if not defined

sign

inline SymbolicFunction &xlifepp::sign(const SymbolicFunction &f)

template<typename T>
int xlifepp::sign(T val)

signe

inline real_t xlifepp::signe(real_t x)

signedDistancesToTriangleEdges

std::vector<real_t> xlifepp::signedDistancesToTriangleEdges(const Point &M, const Point &T1, const Point &T2, const Point &T3)

signed distances of a point M to the three edges of the triangle whose vertices are T1, T2 and T3

signed distances of a point to the 3 edges of a triangle

simplexVertexOutput

void xlifepp::simplexVertexOutput(std::ofstream &os, const int refNum, const int v1, const int v2, const int v3, const int v4)

simpson

template<typename T>
T xlifepp::simpson(const std::vector<T> &f, real_t h)

template<typename T, typename Iterator>
T xlifepp::simpson(number_t n, real_t h, Iterator itb, T &intg)

uniform Simpson method from a list of n (odd) values uniformaly distributed (step h) n: number of values h: step itb: first position in the list of values intg: value of integral

template<typename T>
T xlifepp::simpson(T (*f)(real_t), real_t a, real_t b, number_t n)

uniform Simpson method on [a,b] interval from a function and a number of intervals

template<typename T>
T xlifepp::simpson(T (*f)(real_t, Parameters&), Parameters &pars, real_t a, real_t b, number_t n)

uniform Simpson method on [a,b] interval from a function with parameters and a number of intervals

sin

inline SuTermVector xlifepp::sin(const SuTermVector &s)

inline SymbolicFunction &xlifepp::sin(const SymbolicFunction &f)

inline TermVector xlifepp::sin(const TermVector &s)

sinh

inline SuTermVector xlifepp::sinh(const SuTermVector &s)

inline SymbolicFunction &xlifepp::sinh(const SymbolicFunction &f)

inline TermVector xlifepp::sinh(const TermVector &s)

sinhs

template<typename T>
T xlifepp::sinhs(const T &x)

integrand at (t,z), extern call

sizeOf

inline number_t xlifepp::sizeOf(const complex_t &x)

inline number_t xlifepp::sizeOf(const real_t &x)

inline number_t xlifepp::sizeOf(const std::vector<complex_t> &x)

inline number_t xlifepp::sizeOf(const std::vector<real_t> &x)

inline number_t xlifepp::sizeOf(const std::vector<Vector<complex_t>> &x)

inline number_t xlifepp::sizeOf(const std::vector<Vector<real_t>> &x)

skylinePointer

std::vector<number_t> xlifepp::skylinePointer(const std::vector<number_t>&, const std::vector<number_t>&)

get the skyline pointers from cs pointers

smallPivot

inline bool xlifepp::smallPivot(complex_t piv)

inline bool xlifepp::smallPivot(real_t piv)

smartPtr

template<typename T>
inline SmartPtr<T> xlifepp::smartPtr(T *p)

smartPtrConstCast

template<typename T>
const SmartPtr<typename RemoveConst<T>::type> xlifepp::smartPtrConstCast(const SmartPtr<T> &rhs)

template<typename T>
SmartPtr<typename RemoveConst<T>::type> xlifepp::smartPtrConstCast(SmartPtr<T> &rhs)

smartPtrFromRef

template<typename T>
inline SmartPtr<T> xlifepp::smartPtrFromRef(T *p)

spaces

inline Spaces xlifepp::spaces(const Domains &doms, const Interpolation &inte, bool opt = true)

inline Spaces xlifepp::spaces(const Domains &doms, const Interpolations &ints, bool opt = true)

build a collection of space according to collections of domains and collection of interpolations

inline Spaces xlifepp::spaces(const GeomDomain &dom, const Interpolations &ints, bool opt = true)

sphericalbesselJ0N

std::vector<real_t> xlifepp::sphericalbesselJ0N(real_t x, number_t N)

spherical Bessel function of the first kind and orders 0..N

sphericalbesselJ0NTest

void xlifepp::sphericalbesselJ0NTest(std::ostream &out)

sphericalbesselY0N

std::vector<real_t> xlifepp::sphericalbesselY0N(real_t x, number_t N)

spherical Bessel function of the second kind and orders 0..N

sphericalHarmonics

void xlifepp::sphericalHarmonics(const Point &x, std::vector<std::vector<complex_t>> &ylm)

This function computes spherical harmonics Y_{l}^{m} up to order n on the unit sphere; order n is computed by n=ylm.size()-1 and spherical harmonics ylm are computed for l=0,..,n and m=0,..,l.

Spherical harmonics and derivatives

Spherical harmonics Y^{m}_l up to order n (l=0,..,n; m=0,..,l) on the unit sphere We use here the normalized definition, in which harmonics form an orthonormal basis in L^2(unit_sphere). In spherical coordinates

• \(r = \sqrt{x*^2+y^2+z^2} , \cos\theta = z/r, \tan\phi = y/x\)

• with \(\theta in [0, Pi], \phi in [0, 2*Pi]\), we have the following formula:

\(Y^{m}_{l} = \sqrt{(2*l+1)/4Pi * (l-m)!/(l+m)!} * P^{m}_{l}(\cos\theta) * \exp(i*m*\phi)\)

where \(P^{m}_{l}\) is the m-th associated Legendre polynomial of order l.

\(Y^{m}_{l}\) satisfies for negative m: \(Y^{m}_{l} = (-1)^{m} Y^{-m}_{l}*\) where (terminal) * denotes the complex conjugate.

For spherical harmonics see

• http://en.wikipedia.org/wiki/Spherical_harmonics and for associated Legendre functions

• http://en.wikipedia.org/wiki/Associated_Legendre_polynomials

Y_{l}^{m}= \((-1)^{(|m|-m) /2} \sqrt{ (2l+1)/4\pi*(l-|m|)!/(l+|m|)! } P_{l}^{|m|}(\cos(\theta)) e^{im \phi}\)

which yields for m positive

Y_{l}^{m}= \(\sqrt{ (2l+1)/4\pi*(l-m)!/(l+m)! } P_{l}^{m}(\cos(\theta)) e^{im \phi}\)

Argument ylm is a “triangular 2d array” defined as a std::vector of vectors

the 1st std::vector carries the values: Y_{0}^{0} the 2nd one carries the values: Y_{1}^{0} Y_{1}^{1} and for l=2,..,n the l-th std::vector carries the values: Y_{l}^{0} Y_{l}^{1} .. Y_{l}^{l} if the size of std::vector ylm[l] is l+1.

For a given int n, container ylm can be declared (and defined) prior to call to this function by std::vector<std::vector<complex_t> > ylm(n+1); for (int l=0; l<=n; l++) ylm[l]=std::vector<complex_t>(l+1);

sphericalHarmonicsSurfaceGrad

void xlifepp::sphericalHarmonicsSurfaceGrad(const Point&, std::vector<std::vector<Vector<complex_t>>>&)

Spherical harmonics surface gradient gradS_Y^{m}_l up to order n (l=0,..,n; m=0,..,l) on the unit sphere.

This function computes spherical harmonics surface gradients gradY_{l}^{m} up to order n on the unit sphere; order n is computed by n=ylm.size()-1 and spherical harmonics ylm are computed for l=0,..,n and m=0,..,l.

• Case ( \(\sin(\theta) = 0\)) : . gradS_Y_{l}^{1} = \(\sqrt{ (2l+1)/4\pi * (l-1)! / (l+1)! } * e^{i \phi} * . (P_{l}^{'1}(\cos(\theta)) e_\theta - i (\cos(\theta))^{l+1} \cos(\phi) l(l+1)/2 * e_\phi)\) . where \(e_\theta\) and \(e_\phi\) are the unit tangent std::vector on the unit sphere. . gradS_Y_{l}^{m}(x) = 0 if m =/= 1

• Case ( \(\sin(\theta) /= 0\)) : . gradS_Y_{0}^{0}(x) = 0 . For l > 0 : . gradS_Y_{l}^{m} = \(\sqrt{ (2l+1)/4\pi * (l-m)! / (l+m)! } * e^{im \phi} * . ( P_{l}^{'|m|}(\cos(\theta)) e_\theta + im * P_{l}^{|m|}(\cos(\theta)) e_\phi)\) . where \(e_\theta\) and \(e_\phi\) are the unit tangent std::vector on the unit sphere.

Argument gradylm is a “triangular 2d array of 3d-vectors” defined as a vector of vectors of complex_t-Vectors. the 1st std::vector carries the 3d-vectorial values: gradY_{0}^{0} the 2nd one carries the 3d-vectorial values: gradY_{1}^{0} gradY_{1}^{1} and for l=2,..,n the l-th std::vector carries the 3d-vectorial values: gradY_{l}^{0} gradY_{l}^{1} .. gradY_{l}^{l} where the size of std::vector gradylm[l] is l+1.

For a given int n, container gradylm can be declared (and defined) prior to call to this function by std::vector<std::vector<Vector<complex_t> > > gradylm(n+1); for (int l=0; l<=n; l++) { gradylm[l]=std::vector<Vector<complex_t> >(l+1); for (int m=0; m<=l; m++) gradylm[l][m]=Vector<complex_t>(spaceDim); } where “spaceDim” is previously defined as the dimension space (necessarily 3 here). TELL DANIEL: We may put a test that stops the program if spaceDim is not 3.

sphericalHarmonicsSurfaceGradTest

void xlifepp::sphericalHarmonicsSurfaceGradTest(const Point&, const number_t, std::ostream&)

output function for test of Spherical harmonics and derivatives

sphericalHarmonicsTest

void xlifepp::sphericalHarmonicsTest(const Point&, const number_t, std::ostream&)

output function for test of Spherical harmonics

split

inline Strings xlifepp::split(const string_t &s, char delim = ' ')

split a string into vector of strings using blank space as default delimiter

std::vector<bfPair> xlifepp::split(std::vector<bfPair> &bfs)

splitHexahedronQ1ToTetrahedraP1

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ1ToTetrahedraP1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order tetrahedron elements when splitting first order hexahedron

splitHexahedronQ2ToHexahedraQ1

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ2ToHexahedraQ1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order hexahedron elements when splitting second order hexahedron

splitHexahedronQ2ToTetrahedraP1

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ2ToTetrahedraP1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order tetrahedron elements when splitting second order hexahedron

splitHexahedronQ3ToHexahedraQ1

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ3ToHexahedraQ1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order hexahedron elements when splitting third order hexahedron

splitHexahedronQ3ToTetrahedraP1

std::vector<std::vector<number_t>> xlifepp::splitHexahedronQ3ToTetrahedraP1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order tetrahedron elements when splitting third order hexahedron

splitInTriangles

std::vector<std::vector<number_t>> xlifepp::splitInTriangles(const std::vector<Point> &pts)

splitNumbersFind

bool xlifepp::splitNumbersFind(std::vector<std::vector<number_t>> splitnum, std::vector<number_t> num)

return nodes numbers by removing duplicates

splitNumbersMerge

std::vector<std::vector<number_t>> xlifepp::splitNumbersMerge(std::vector<std::vector<number_t>> splitnum1, std::vector<std::vector<number_t>> splitnum2)

splitNumbersUnique

std::vector<std::vector<number_t>> xlifepp::splitNumbersUnique(std::vector<std::vector<number_t>> splitnum)

return nodes numbers by removing duplicates

splitTetrahedronP2ToTetrahedraP1

std::vector<std::vector<number_t>> xlifepp::splitTetrahedronP2ToTetrahedraP1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order tetrahedron elements when splitting second order tetrahedron

splitTetrahedronP3ToTetrahedraP1

std::vector<std::vector<number_t>> xlifepp::splitTetrahedronP3ToTetrahedraP1(std::vector<number_t> nodeNumbers)

return nodes numbers of first order tetrahedron elements when splitting third order tetrahedron

sqrt

inline SuTermVector xlifepp::sqrt(const SuTermVector &s)

inline SymbolicFunction &xlifepp::sqrt(const SymbolicFunction &f)

inline TermVector xlifepp::sqrt(const TermVector &s)

template<typename K>
Vector<K> xlifepp::sqrt(const Vector<K> &v)

sqrt(v)

sqrt2_over_pi

static const real_t xlifepp::sqrt2_over_pi(std::sqrt(two_over_pi))

squared

inline SuTermVector xlifepp::squared(const SuTermVector &s)

inline SymbolicFunction &xlifepp::squared(const SymbolicFunction &f)

inline TermVector xlifepp::squared(const TermVector &s)

squareDistance

real_t xlifepp::squareDistance(const Point&, const Point&)

returns the square distance between two points

storedLines

static bool xlifepp::storedLines(MatrixEntry *mat, const std::vector<number_t> &rank, number_t nbl, bool byCol, std::vector<std::vector<std::pair<number_t, number_t>>> &lines)

stored coefficients of some columns (byCol=true) or rows (byCol=false) of a matrix, extracted in one pass from the list of the stored coefficients (see MatrixStorage::storedPositions): lines[k-1] = list of (row or col index, address) of the line of rank k, rank[l] = rank of the line l (0 if the line is not selected), nbl the number of selected lines only for a scalar matrix with a compressed storage where each coefficient has its own address (so not a symmetric storage of a symmetric matrix), returns false else (the generic algorithms using getRows, getCol, … are used)

storeEigenVector

void xlifepp::storeEigenVector(const TermMatrix *A_p, ValueType vt, bool singleUnknown, VectorEntry *eigvec, TermVector &resVec)

Utility function to store data of an eigenvector into a TermVector.

storeElSides

void xlifepp::storeElSides(const GeomElement *el_p, number_t noelt, SIDELTMAP &parentEl, const vector<bool> *marked)

str

string_t xlifepp::str(const Parameter&)

cast to string_t

stringto

template<typename T>
T xlifepp::stringto(const string_t &s)

returns string converted to T

struct2Str

string_t xlifepp::struct2Str(StrucType s)

strucType

inline StrucType xlifepp::strucType(const complex_t &x)

inline StrucType xlifepp::strucType(const real_t &x)

template<typename T>
inline StrucType xlifepp::strucType(const std::vector<T> &x)

struveNotH0

real_t xlifepp::struveNotH0(real_t x)

Struve function of order 0, H_0(x) returns H_0(x) for any |x|<=8, H_0(x)-Y_0(x) for any |x|>8.

struveNotH01

std::pair<real_t, real_t> xlifepp::struveNotH01(real_t x)

returns both H_0(x) and H_1(x) for any |x|<8, returns H_0(x)-Y_0(x) and H_1(x)-Y_1(x) for any |x|>8.

struveNotH1

real_t xlifepp::struveNotH1(real_t x)

Struve function of order 1, H_1(x) returns H_1(x) for any |x|<=‡8, H_1(x)-Y_1(x) for any |x|>8.

subSpace

Space &xlifepp::subSpace(Space &sp, const GeomDomain &dom)

return sub-space or trace space on domain of a space, created if not exist

substrCanonicalAndCanonical

void xlifepp::substrCanonicalAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)

substrCanonicalAndComposite

void xlifepp::substrCanonicalAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)

substrCanonicalAndLoop

void xlifepp::substrCanonicalAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)

substrCompositeAndCanonical

void xlifepp::substrCompositeAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)

substrCompositeAndComposite

void xlifepp::substrCompositeAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)

substrCompositeAndLoop

void xlifepp::substrCompositeAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)

substrLoopAndCanonical

void xlifepp::substrLoopAndCanonical(const Geometry &g1, const Geometry &g2, Geometry &g)

substrLoopAndComposite

void xlifepp::substrLoopAndComposite(const Geometry &g1, const Geometry &g2, Geometry &g)

substrLoopAndLoop

void xlifepp::substrLoopAndLoop(const Geometry &g1, const Geometry &g2, Geometry &g)

surfaceFrom

Geometry xlifepp::surfaceFrom(const Geometry &c, string_t domName, bool isPlaneSurface)

definition of a geometry 2D from its boundary 1D

definition of a geometry 2D from an union of boundaries 1D

surfToArcParametrizationu0

Vector<real_t> xlifepp::surfToArcParametrizationu0(const Point &p, Parameters &pars, DiffOpType d)

surfToArcParametrizationu1

Vector<real_t> xlifepp::surfToArcParametrizationu1(const Point &p, Parameters &pars, DiffOpType d)

surfToArcParametrizationv0

Vector<real_t> xlifepp::surfToArcParametrizationv0(const Point &p, Parameters &pars, DiffOpType d)

surfToArcParametrizationv1

Vector<real_t> xlifepp::surfToArcParametrizationv1(const Point &p, Parameters &pars, DiffOpType d)

svd

template<typename T>
LowRankMatrix<T> &xlifepp::svd(const LargeMatrix<T> &lm, LowRankMatrix<T> &lrm, number_t r = 0, real_t eps = theTolerance)

svd of a LargeMatrix

SVD compression method of a LargeMatrix to a LowRankMatrix Lr produce the best matrix approximation Lr of rank r (see Eckart-Young-Mirsky theorem)

T: type of the result lm: LargeMatrix to be compressed r: prescribed rank of truncature, if 0 not used, the real rank at output eps: prescribed precision, if rk > 0 not used r=0 and eps=0 gives the full svd lrm: LowRankMatrix

template<typename T>
void xlifepp::svd(Matrix<T> &A, Matrix<T> &U, Vector<T> &D, Matrix<T> &V, number_t r = 0, real_t eps = 0.)

SVD or truncated SVD with either rank or precision truncation T: type of the matrix (real or complex) A: Matrix to be be factorized U,D,V: SVD factors A=U*D*V’ or A~U*D*V’ (output) r: prescribed rank eps: singularvalue threshold if r > 0, the SVD is restricted to the first r singular values else it is restricted to the first singular values smaller than eps rmk: r=0 and eps=0 gives the full svd.

template<typename T>
void xlifepp::svd(T *A, number_t m, number_t n, T *U, T *D, T *V, number_t &rk, real_t eps = 0.)

general template svd using Eigen, assuming A, U, V are pointers to first value of DENSE ROW matrix A: pointer to dense row matrix m,n: number of rows and cols of A U, V: pointer to dense row matrices, has to be allocated before S: pointer to S vector, has to be allocated before rk: prescribed rank of truncature, if 0 not used, the real rank at output eps: prescribed precision, if rk > 0 not used r=0 and eps=0 gives the full svd

note: may be used when A is a pointer to a m x n col dense matrix, by permuting arguments when calling: svd(A,n,m,V,D,U,rk,eps) produces the SVD of A produces the SVD of A = U*D*V’ where U, V are pointers to row dense matrices!

SvdElements xlifepp::svd(TermMatrix *A, const std::vector<Parameter> &ps)

Main entry point for SVD decomposition using Arpack.

symAmd

bool xlifepp::symAmd(number_t nbr, number_t nbc, const std::vector<number_t> &colIndices, const std::vector<number_t> &rowPointer, std::vector<number_t> &colPerm)

symb

inline SymbolicTermMatrix &xlifepp::symb(const TermMatrix &M)

symbolic_curabc

Vector<real_t> xlifepp::symbolic_curabc(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization curvilinear abcissa

symbolic_curvature

Vector<real_t> xlifepp::symbolic_curvature(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization curvature

symbolic_f

Vector<real_t> xlifepp::symbolic_f(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization f

symbolic_invParametrization

Vector<real_t> xlifepp::symbolic_invParametrization(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization invParametrization

symbolic_length

Vector<real_t> xlifepp::symbolic_length(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization length

symbolic_normal

Vector<real_t> xlifepp::symbolic_normal(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization normal

symbolic_tangent

Vector<real_t> xlifepp::symbolic_tangent(const Point&, Parameters&, DiffOpType)

to deal with symbolic paramerization tangent

tan

inline SuTermVector xlifepp::tan(const SuTermVector &s)

inline SymbolicFunction &xlifepp::tan(const SymbolicFunction &f)

inline TermVector xlifepp::tan(const TermVector &s)

tangent_Piecewise

inline Vector<real_t> xlifepp::tangent_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)

extern parametrization call

tanh

inline SuTermVector xlifepp::tanh(const SuTermVector &s)

inline SymbolicFunction &xlifepp::tanh(const SymbolicFunction &f)

inline TermVector xlifepp::tanh(const TermVector &s)

tensorCrossProduct

SuTermVector xlifepp::tensorCrossProduct(const SuTermVector &tv1, const SuTermVector &tv2)

tensor cross product => vector SuTermVector in 3D, scalar SuTermVector in 2D

tensor hermitian product => scalar SuTermVector

TermVector xlifepp::tensorCrossProduct(const TermVector &s1, const TermVector &s2)

tensor cross product of single unknown vector TermVector => single unknown vector/scalar TermVector (in 3D/2D)

tensorHermitianProduct

SuTermVector xlifepp::tensorHermitianProduct(const SuTermVector &tv1, const SuTermVector &tv2)

tensor hermitian product => scalar SuTermVector (conjugate tv2 if it is complex) produce vector of hermitian product of components SuTermVector must have same same dofs and same number of components the SutermVector result has unknown and space of tv1

tensor inner product => scalar SuTermVector (not conjugate)

TermVector xlifepp::tensorHermitianProduct(const TermVector &s1, const TermVector &s2)

tensor hermitian product of single unknown vector TermVector => single unknown scalar TermVector

tensorHexahedronSideNumbering

void xlifepp::tensorHexahedronSideNumbering(number_t *&sh1, number_t *&sh2, number_t &p, const int interpNum, const number_t qq1, const number_t qq2, const number_t qq3, const number_t qq4, const short int sens)

correspondence between segment and quadrangular face numbering

correspondence between segment and hexahedron face local numbering

Examples of local numbering of Lagrange Pk 1D elements

 2----1  2---3---1  2---4---3---1  2---5---4---3---1  2---6---5---4---3---1
   k=1      k=2          k=3              k=4                  k=5

• point number p has coordinates defined by

• ( x = coords[s2h[0][p]], y = coords[s2h[1][p]], z = coords[s2h[3][p]] )

• where coords are coordinates of the associated 1D Lagrange reference element

• and

• shape functions are defined by tensor product of shape functions of the 1D reference element

• w3_p(x,y,z) = w1_{s2h[0][p]}(x) * w1_{s2h[1][p]}(y) * w1_{s2h[2][p]}(z)

• where w1_k is the k-th shape function of the associated 1D Lagrange reference element

tensorInnerProduct

SuTermVector xlifepp::tensorInnerProduct(const SuTermVector &tv1, const SuTermVector &tv2)

tensor inner product => scalar SuTermVector (not conjugate when tv2 is complex) produce vector of inner product of components SuTermVector must have same same dofs and same number of components the SutermVector result has unknown and space of tv1

TermVector xlifepp::tensorInnerProduct(const TermVector &s1, const TermVector &s2)

tensor inner product of single unknown vector TermVector => single unknown scalar TermVector (not conjugate)

tensorNumbering

template<class ST_>
void xlifepp::tensorNumbering(const int interpNum, number_t **&s2h)

template<class ST_>
void xlifepp::tensorNumbering(const int interpNum, std::vector<number_t> &s2t)

tensorNumberingHexahedron

void xlifepp::tensorNumberingHexahedron(const int interpNum, number_t **&s2h)

tensorNumberingHexahedron: correspondence between segment and hexahedron local numbering

correspondence between segment and hexahedron local numbering such that

tensorNumberingQuadrangle

void xlifepp::tensorNumberingQuadrangle(const int interpNum, std::vector<number_t> &s2q)

tensorNumberingQuadrangle: correspondence between segment and quadrangle local numbering

correspondence between segment and quadrangle local numbering

point number p has coordinates defined by ( x = coords[s2q[2*p]], y = coords[s2q[2*p+1]] ) where coords are coordinates of the associated 1D Lagrange reference element and shape functions are defined by tensor product of shape functions of the 1D reference element w2_p(x,y) = w1_{s2q[2*p]}(x) * w1_{s2q[2*p+1]}(y) where w1_k is the k-th shape function of the associated 1D Lagrange reference element

tensorNumberingTetrahedron

void xlifepp::tensorNumberingTetrahedron(const int interpNum, number_t **&s2t)

correspondance between segment and tetrahedron local numbering defined such that

correspondence between segment and hexahedron local numbering such that

• point number p has coordinates defined by

• ( x = coords[s2h[0][p]], y = coords[s2h[1][p]], z = coords[s2h[3][p]] ) where coords are coordinates of the associated 1D Lagrange reference element -&#8212; No longer used –&#8212;

tensorNumberingTriangle

void xlifepp::tensorNumberingTriangle(const int interpNum, std::vector<number_t> &s2t)

point number p has coordinates defined by ( x = coords[s2q[2*p]], y = coords[s2q[2*p+1]] ) where coords are coordinates of the associated 1D Lagrange reference element

correspondence between segment and triangle local numbering

Examples of local numbering of Lagrange Pk 1D elements 2&#8212;1 2&#8212;3&#8212;1 2&#8212;4&#8212;3&#8212;1 2&#8212;5&#8212;4&#8212;3&#8212;1 2&#8212;6&#8212;5&#8212;4&#8212;3&#8212;1 2&#8212;7&#8212;6&#8212;5&#8212;4&#8212;3&#8212;1 . k=1 k=2 k=3 k=4 k=5 k=6 Examples of local numbering of Lagrange Pk triangles

2 2 2 2 2 2 | \ | \ | \ | \ | \ | \ 3&#8212;1 5 4 5 7 5 10 5 13 5 16 . k=1 | \ | \ | \ | \ | \ ……. 3&#8212;6&#8212;1 8 10 4 8 14 7 8 17 10 8 20 13 ………. k=2 | \ | | \ \ | | \ \ | | \ \ ……………… 3&#8212;6&#8212;9&#8212;1 11 15&#8212;13 4 11 20 19 7 11 23 25 10 …………………… k=3 | \ | | \ \ | | \ \ …………………………… 3&#8212;6&#8212;9&#8212;12&#8212;1 14 18&#8212;21&#8212;16 4 14 26 28 22 7 …………………………………… k=4 | \ | | \ \ ……………………………………………. 3&#8212;6&#8212;9&#8212;12&#8212;15&#8212;1 17 21&#8212;24&#8212;27&#8212;19 4 ……………………………………………………. k=5 | \ ………………………………………………………………… 3&#8212;6&#8212;9&#8212;12&#8212;15&#8212;18&#8212;1 ………………………………………………………………………….. k=6

tensorOpAdd

template<typename T, typename KU, typename KV>
inline void xlifepp::tensorOpAdd(const AlgebraicOperator &op, const std::vector<KU> &u, number_t nu, const std::vector<KV> &v, number_t nv, Matrix<T> &mat, const T &alpha, bool isDiag = false)

evaluate “tensor” operation between 2 small vectors, and add it to a given a nu x nv matrix mat (stored by rows)

op: algebraic operator involved (either product, inner product, cross product, contracted product) alpha is a coefficient applied to the added “tensor” matrix u (resp. v) is

• either a list of nu scalar values (resp. nv scalar values)

• or a list of nbu (resp. nbv) vector values (u_1,u_2,..u_nu) stored as (u_1)1 …(u_1)mu (u_2)1 … (u_2)mu …..(u_nu)1 …(u_nu)mu with mu=u.size()/nu for scalar case (mu=mv=1) all product are equivalent for vector case (mu=mv>1) only inner product is currently available for matrix case (mu=mv>1) only contracted product is currently available when isDiag=true deal only with diagonal coefficients

template<typename T, typename iteratorM, typename iteratorK>
inline void xlifepp::tensorOpAdd(const AlgebraicOperator &opu, const AlgebraicOperator &opv, const std::vector<T> &u, number_t nu, const std::vector<T> &v, number_t nv, iteratorM itm, iteratorK itk, number_t mk, number_t nk)

evaluate “tensor” operation between 2 small vectors and “coefficient” ker, and add it to a given a nu x nv matrix mat (stored by rows) u opu ker opv v u (resp.

v) is

• either a list of nu scalar values (resp. nv scalar values)

• or a list of nbu (resp. nbv) vector values (u_1,u_2,..u_nu) stored as (u_1)1 …(u_1)mu (u_2)1 … (u_2)mu …..(u_nu)1 …(u_nu)mu with mu=u.size()/nu for scalar case (mu=mv=1) all product are equivalent for vector case (mu=mv>1) only inner product is currently available

itk is an iterator to the kernel part (either a scalar, a vector (mk or nk) or a matrix (mk x nk))

tensorProductTpl

template<typename T1_iterator, typename T2_iterator, typename R_iterator>
void xlifepp::tensorProductTpl(T1_iterator b1, T1_iterator e1, T2_iterator b2, T2_iterator e2, R_iterator Rb)

accumulated tensor product: “R[i,j] = R[i,j] + T1[i] * T2[j]”

tensorTetrahedronSideNumbering

void xlifepp::tensorTetrahedronSideNumbering(const int nk, const dimen_t i0, const dimen_t i1, const dimen_t i2, const number_t z1, const number_t xx1, const number_t xx2, number_t **&s2t, number_t &p)

tetrahedraIntersect

bool xlifepp::tetrahedraIntersect(const Point &A1, const Point &B1, const Point &C1, const Point &D1, const Point &A2, const Point &B2, const Point &C2, const Point &D2)

tetrahedraOverlap

bool xlifepp::tetrahedraOverlap(const std::vector<Point> &t1, const std::vector<Point> &t2)

implementation of the “Separating Axis Test” for a pair of tetrahedra

determines if 2 tetrahedra overlap

The main idea is that if tetrahedra does not overlap, there exists an axis where their projections does not overlap This axis has one of the following properties:

• the axis is orthogonal to one face of one of the tetrahedra

• the axis is orthogonal to an edge on each tetrahedron

overlapping means intersection has a non null measure

The main idea of the method is to test each face of both tetrahedra then test each pair of edges (one per tetrahedron) If one of these elementary tests separates, then false is returned (no overlap), else their is overlapping

tetrahedronCrouzeixRaviartStd

RefElement *xlifepp::tetrahedronCrouzeixRaviartStd(const Interpolation *interp_p)

tetrahedronCrouzeixRaviartStd construction of a CrouzeixRaviart Reference Element by interpolation number

tetrahedronLagrangeStd

RefElement *xlifepp::tetrahedronLagrangeStd(const Interpolation *interp_p)

tetrahedronLagrangeStd construction of a Lagrange standard Reference Element by interpolation number particular formulae up to P3 else general method using monomes basis

tetrahedronNedelecEdge

RefElement *xlifepp::tetrahedronNedelecEdge(const Interpolation *interp_p)

tetrahedronNedelecFace

RefElement *xlifepp::tetrahedronNedelecFace(const Interpolation *interp_p)

tetrahedronQuadrature

Quadrature *xlifepp::tetrahedronQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit tetrahedron

tetrahedronVolume

real_t xlifepp::tetrahedronVolume(const Point&, const Point&, const Point&, const Point&)

volume of a tetrahedron

theDate

string_t xlifepp::theDate()

returns current date as dd.mmm.yyyy

returns current date as dd.mmm.yyyy e.g.

29.feb.2004

theIsoDate

string_t xlifepp::theIsoDate()

returns ISO8601 format of current date (yyyy-mm-dd)

returns ISO8601 format of current date (yyyy-mm-dd), e.g.

2004-02-29

theIsoTime

string_t xlifepp::theIsoTime()

returns ISO8601 format of current date (hh-mi-ss)

returns ISO8601 format of current time (hh-mi-ss), e.g.

04-39-51

theLongDate

string_t xlifepp::theLongDate()

returns current date as Month Day, Year (en) or Day Month Year (fr)

theShortDate

string_t xlifepp::theShortDate()

returns current date as mm/dd/yyyy (en) or dd/mm/yyyy (fr)

theTime

string_t xlifepp::theTime()

returns current time

returns current time e.g.

04h32

timerInit

void xlifepp::timerInit()

initialization procedure for time handling

initialization of engine for time handling

timesn

OperatorOnFunction &xlifepp::timesn(const Function&)

f*n

OperatorOnFunction &xlifepp::timesn(OperatorOnFunction&)

opf*n

timesncrossn

OperatorOnFunction &xlifepp::timesncrossn(const Function&)

f*(n^n)

OperatorOnFunction &xlifepp::timesncrossn(OperatorOnFunction&)

opf*(n^n)

to2D

std::vector<Point> xlifepp::to2D(const std::vector<Point> &p)

std::vector<Point> xlifepp::to2D(const std::vector<Point> &p, Point &u, Point &v, Point &w)

toBarycentric

Point xlifepp::toBarycentric(const Point &M, const Point &S1, const Point &S2, const Point &S3, const Point &S4)

return barycentric coordinates of a point M related to segment (S1,S2), to triangle (S1,S3,S3), to tetrahedron (S1,S2,S3,S4) checking degenerancy of simplex

toBarycentricNocheck

Point xlifepp::toBarycentricNocheck(const Point &M, const Point &S1, const Point &S2, const Point &S3, const Point &S4)

return barycentric coordinates of a point M related to segment (S1,S2), to triangle (S1,S3,S3), to tetrahedron (S1,S2,S3,S4) works in 2D, 3D, does not require that M belongs to line (S1,S2) or plane (S1,S2,S3) in that case, it gives the barycentric coordinates of the orthogonal projection of M on line or plane if fails (degenerated simplex), return a void Point

toComplex

inline SuTermVector xlifepp::toComplex(const SuTermVector &s)

TermMatrix xlifepp::toComplex(const TermMatrix &tm)

return the complex representation of the given TermMatrix

inline void xlifepp::toComplex(real_t x, real_t y, complex_t &z)

load table from file

inline void xlifepp::toComplex(real_t x, real_t y, real_t &z)

toComposite

Geometry xlifepp::toComposite(const Geometry &g)

conversion of a canonical or loop Geometry into a composite geometry with one component

return a composite geometry with only one component: g

• if g is canonical, the components_ vector contains only g

• if g is loop, the components_ vector contains every border of g and g itself

• if g is composite, it does nothing

this function is necessary when initializing composite Geometry before using += and -= operators

Transformation xlifepp::toComposite(const Transformation &t)

conversion of a canonical Transformation into a composite Transformation with one component

return a composite Transformation with only one component: t

• if t is canonical, the components_ vector contains only t

• if t is composite, it does nothing

this function is necessary when initializing composite Transformation before using += operator

toEllipticCoordinates

Point xlifepp::toEllipticCoordinates(const Point &P, const Point &C, const Point &A1, const Point &A2)

returns (r,theta,phi) coordinates of a point related to an ellipsoid (C center, A1,A2,A3 the three apogees) P-C = r(A1-C)) cos(theta) cos(phi) + r(A2-C) sin(theta) cos(phi) + r(A3-C) sin(phi) r >=0 , azymuth theta in ]-pi,pi], elevation phi in [-pi/2,pi/2] NB: if C=(0,0,0), A1=(1,0,0), A2=(0,1,0), A3=(0,0,1) then it gives the usual sperical coordinates r=1 on the boundary of the ellisoid

returns (r,theta) related to the ellipse (C,A1,A2)

Point xlifepp::toEllipticCoordinates(const Point &P, const Point &C, const Point &A1, const Point &A2, const Point &A3)

returns (r,theta,phi) related to the ellipsoid (C,A1,A2,A3)

Point xlifepp::toEllipticCoordinates(const Point &P, real_t r1, real_t r2)

returns (r,theta) coordinates of a point related to an a centered orthogonal ellipse with radius r1,r2 calls general case (not the fastest method)

returns (r,theta) related to the orthogonal ellipse of size (r1,r2)

Point xlifepp::toEllipticCoordinates(const Point &P, real_t r1, real_t r2, real_t r3)

returns (r,theta,phi) coordinates of a point related to an a centered orthogonal ellipsoid with radius r1,r2,r3 calls general case (not the fastest method)

returns (r,theta,phi) related to the orthogonal ellipsoid of size (r1,r2,r3) compute barycentric coordinates related to segment, triangle or tetrahedron

toOperatorOnUnknown

OperatorOnUnknown xlifepp::toOperatorOnUnknown(const KernelOperatorOnTermVector &koptv)

OperatorOnUnknown xlifepp::toOperatorOnUnknown(const KernelOperatorOnUnknowns&)

move partial KernelOperatorOnUnknowns to OperatorOnUnknown

toPolar

Point xlifepp::toPolar(const Point &P)

returns Point as Point in spherical coordinates (r,theta,phi) r=sqrt(x*x+y*y+z*z) azymuth theta = atan2(y,x) in ]-pi,pi], elevation phi = asin(z/r) in [-pi/2,pi/2] reverse map: x= r cos(theta) cos(phi), y = r sin(theta) cos(phi), z = r sin(phi)

returns Point as Point in polar/cylindrical coordinates

toRealComplex

complex_t xlifepp::toRealComplex(const Vector<complex_t>&, const complex_t &c)

real_t xlifepp::toRealComplex(const Vector<real_t> &v, const complex_t &c)

special cast function used by FEComputation’s

complex_t xlifepp::toRealComplex(const Vector<Vector<complex_t>> &v, const complex_t &c)

real_t xlifepp::toRealComplex(const Vector<Vector<real_t>> &v, const complex_t &c)

toSpherical

Point xlifepp::toSpherical(const Point &P)

returns (r,theta) coordinates of a point related to an ellipse (C center, A1,A2, the two apogees) P-C = r(A1-C)) cos(theta) + r(A2-C) sin(theta) r >=0 , azymuth theta in ]-pi,pi] NB: if C=(0,0), A1=(1,0), A2=(0,1) then it gives the usual polar coordinates r=1 on the boundary of the ellipse

returns Point as Point in spherical coordinates

tostring

template<typename T>
string_t xlifepp::tostring(const T &t)

returns T converted to string

totalCpuTime

real_t xlifepp::totalCpuTime()

returns user time (“cputime”) interval since first runtime ‘call’ according to unit defined in Time::deltacpuTime

returns elapsed time interval in sec.

since first runtime ‘call’

real_t xlifepp::totalCpuTime(const string_t &comment, CoutStream &out)

real_t xlifepp::totalCpuTime(const string_t &comment, PrintStream &out)

real_t xlifepp::totalCpuTime(const string_t &comment, std::ostream &out = std::cout)

returns elapsed time interval in sec.

since first runtime ‘call’ and prints it with comment

totalElapsedTime

real_t xlifepp::totalElapsedTime()

returns elapsed time interval since first runtime ‘call’ according to unit defined in Time::deltaTime

returns elapsed time interval in sec.

since first runtime ‘call’

real_t xlifepp::totalElapsedTime(const string_t &comment, CoutStream &out)

real_t xlifepp::totalElapsedTime(const string_t &comment, PrintStream &out)

real_t xlifepp::totalElapsedTime(const string_t &comment, std::ostream &out = std::cout)

returns elapsed time interval in sec.

since first runtime ‘call’ and prints it with comment

toVector

Vector<real_t> xlifepp::toVector(const Point &p)

return Point as a Vector<real_t>

return as Vector

returns q-p as VectorVector<real_t>

Vector<real_t> xlifepp::toVector(const Point &p, const Point &q)

return q-p as Vector

trac_x

OperatorOnKernel &xlifepp::trac_x(const Kernel&)

trac_x(k)

OperatorOnKernel &xlifepp::trac_x(OperatorOnKernel&)

trac_x(opk)

trac_y

OperatorOnKernel &xlifepp::trac_y(const Kernel&)

trac_y(k)

OperatorOnKernel &xlifepp::trac_y(OperatorOnKernel&)

trac_y(opk)

traceInit

void xlifepp::traceInit()

initialization procedure for trace handling

initialization of engine for trace handling

tran

inline complex_t xlifepp::tran(const complex_t&)

template<typename K>
Matrix<K> xlifepp::tran(const Matrix<K> &kB)

transpose matrix

inline const Point &xlifepp::tran(const Point &p)

inline real_t xlifepp::tran(const real_t&)

template<typename K>
SparseMatrix<K> xlifepp::tran(const SparseMatrix<K> &m)

transpose matrix

template<typename T>
inline const std::vector<T> &xlifepp::tran(const std::vector<T> &v)

template<typename T>
inline const Vector<T> &xlifepp::tran(const Vector<T> &v)

OperatorOnFunction &xlifepp::tran(Function&)

transpose f

OperatorOnKernel &xlifepp::tran(Kernel&)

transpose k

OperatorOnFunction &xlifepp::tran(OperatorOnFunction&)

transpose opf

OperatorOnKernel &xlifepp::tran(OperatorOnKernel&)

transpose opk

SymbolicTermMatrix &xlifepp::tran(SymbolicTermMatrix &S)

template<typename T>
inline Function &xlifepp::tran(T (*fun)(const Point&, const Point&, Parameters&))

template<typename T>
inline Function &xlifepp::tran(T (*fun)(const Point&, Parameters&))

template<typename T>
inline Function &xlifepp::tran(T (*fun)(const Vector<Point>&, const Vector<Point>&, Parameters&))

template<typename T>
inline Function &xlifepp::tran(T (*fun)(const Vector<Point>&, Parameters&))

trans

template<typename T>
Value &xlifepp::trans(const T &v)

Value &xlifepp::trans(Value &v)

set to true or false the temporary transpose flag

transform

template<class Geom>
Geom xlifepp::transform(const Geom &g, const Transformation &t)

apply a geometrical transformation on a Geom (template external)

Geometry xlifepp::transform(const Geometry &g, const Transformation &t)

apply a geometrical transformation on a Geometry (external)

Mesh xlifepp::transform(const Mesh &m, const Transformation &t, const string_t &meshname = "", const string_t &suffix = "")

apply a geometrical transformation on a Mesh (external)

inline Point xlifepp::transform(const Point &p, const Transformation &t)

apply a geometrical transformation on a Point

transformMatrix

template<typename K>
void xlifepp::transformMatrix(MatrixEigenDense<K> &mat)

Reverse all elements of a matrix.

transformVectorDense

template<typename K>
void xlifepp::transformVectorDense(VectorEigenDense<K> &v)

translate

template<class Geom>
Geom xlifepp::translate(const Geom &g, const Parameter &p1)

apply a translation on a Geom (1 key) (template external)

template<class Geom>
Geom xlifepp::translate(const Geom &g, real_t ux, real_t uy, real_t uz = 0.)

apply a translation on a Geom (3 reals version) (template external)

template<class Geom>
Geom xlifepp::translate(const Geom &g, std::vector<real_t> u = std::vector<real_t>(3, 0.))

apply a translation on a Geom (vector version) (template external)

inline Geometry xlifepp::translate(const Geometry &g, const Parameter &p1)

apply a translation on a Geometry (1 key) (template external)

inline Geometry xlifepp::translate(const Geometry &g, real_t ux, real_t uy, real_t uz = 0.)

apply a translation on a Geometry (3 reals version) (template external)

inline Geometry xlifepp::translate(const Geometry &g, std::vector<real_t> u = std::vector<real_t>(3, 0.))

apply a translation on a Geometry (vector version) (template external)

Mesh xlifepp::translate(const Mesh &m)

apply a translation on a Mesh (vector version) (external)

apply a translation on a Mesh (no vector) (external)

Mesh xlifepp::translate(const Mesh &m, const Parameter &p1)

apply a translation on a Mesh (1 key) (external)

Mesh xlifepp::translate(const Mesh &m, const Parameter &p1, const Parameter &p2)

apply a translation on a Mesh (2 keys) (external)

Mesh xlifepp::translate(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)

apply a translation on a Mesh (3 keys) (external)

Mesh xlifepp::translate(const Mesh &m, real_t ux, real_t uy = 0., real_t uz = 0.)

apply a translation on a Mesh (3 reals version) (external)

Mesh xlifepp::translate(const Mesh &m, std::vector<real_t> u)

apply a translation on a Mesh (vector version) (external)

inline Point xlifepp::translate(const Point &g, const Parameter &p1)

apply a translation on a Point (1 key) (template external)

inline Point xlifepp::translate(const Point &g, real_t ux, real_t uy, real_t uz = 0.)

apply a translation on a Point (3 reals version) (template external)

inline Point xlifepp::translate(const Point &g, std::vector<real_t> u = std::vector<real_t>(3, 0.))

apply a translation on a Point (vector version) (template external)

transpose

inline complex_t xlifepp::transpose(const complex_t &c)

template<typename M_it, typename MM_it>
void xlifepp::transpose(const dimen_t nbr, const dimen_t nbc, M_it it_m1b, MM_it it_m2b)

template<typename T>
LargeMatrix<T> xlifepp::transpose(const LargeMatrix<T> &L)

template<typename K>
Matrix<K> xlifepp::transpose(const Matrix<K> &kB)

transpose matrix

template<typename K>
MatrixEigenDense<K> xlifepp::transpose(const MatrixEigenDense<K> &mat)

inline real_t xlifepp::transpose(const real_t &r)

template<typename K>
SparseMatrix<K> xlifepp::transpose(const SparseMatrix<K> &m)

transposeVec

template<typename K>
VectorEigenDense<K> xlifepp::transposeVec(const VectorEigenDense<K> &v)

Transpose a vector.

Parameters:

v – [in] source vector

Returns:

transposed vector

trapz

template<typename T>
T xlifepp::trapz(const std::vector<T> &f, real_t h)

template<typename T, typename Iterator>
T xlifepp::trapz(number_t n, real_t h, Iterator itb, T &intg)

uniform trapeze method from a list of n values uniformaly distributed (step h) n: number of values h: step itb: first position in the list of values intg: value of integral

template<typename T>
T xlifepp::trapz(T (*f)(real_t), real_t a, real_t b, number_t n)

uniform trapeze method on [a,b] interval from a function and a number of points

template<typename T>
T xlifepp::trapz(T (*f)(real_t, Parameters&), Parameters &pars, real_t a, real_t b, number_t n)

uniform trapeze method on [a,b] interval from a function with parameters and a number of points

treeToSet

std::set<GeomElement*> xlifepp::treeToSet(Node<GeomElement> &tree)

triangleArea

real_t xlifepp::triangleArea(const Point&, const Point&, const Point&)

area of a triangle

triangleArgyris

RefElement *xlifepp::triangleArgyris(const Interpolation *interp_p)

triangleMorley construction of the Morley Reference Element

triangleCrouzeixRaviartStd

RefElement *xlifepp::triangleCrouzeixRaviartStd(const Interpolation *interp_p)

triangleCrouzeixRaviartStd construction of a Crouzeix_Raviart standard Reference Element by interpolation number

triangleEdgesLengths

std::vector<real_t> xlifepp::triangleEdgesLengths(const Point &T1, const Point &T2, const Point &T3)

lengths of edges of the triangle whose vertices are T1, T2 and T3 first edge is T2T3, second height T1T3 and last height T1T2

lengths of edges of the triangle whose vertices are given

triangleHeightsLengths

std::vector<real_t> xlifepp::triangleHeightsLengths(const Point &T1, const Point &T2, const Point &T3)

lengths of heights of the triangle whose vertices are T1, T2 and T3 first height is from T1, second height from T2 and last height from T3

lengths of heights of the triangle whose vertices are given

triangleHermiteStd

RefElement *xlifepp::triangleHermiteStd(const Interpolation *interp_p)

triangleHermiteStd construction of a Hermite standard Reference Element by interpolation number

triangleLagrangeStd

RefElement *xlifepp::triangleLagrangeStd(const Interpolation *interp_p)

triangleLagrangeStd construction of a Lagrange standard Reference Element by interpolation number

triangleMorley

RefElement *xlifepp::triangleMorley(const Interpolation *interp_p)

triangleMorley construction of the Morley Reference Element

triangleNedelec

RefElement *xlifepp::triangleNedelec(const Interpolation *interp_p)

triangleNedelec construction of a Nedelec standard Reference Element by interpolation number

triangleQuadrature

Quadrature *xlifepp::triangleQuadrature(QuadRule, number_t)

find or create quadrature rule over the unit triangle

triangleRaviartThomasStd

RefElement *xlifepp::triangleRaviartThomasStd(const Interpolation *interp_p)

triangleRaviart_ThomasStd construction of a Raviart_Thomas standard Reference Element by interpolation number

trihedralOrientation

std::vector<std::pair<real_t, dimen_t>> xlifepp::trihedralOrientation(const Point &o, const Point &px, const Point &py, const Point &pz)

computes orientation of a trihedral, namely rotation angles around each axis to come from the standard trihedral to the given one basic idea:

computes orientation of a trihedral

• first we determine the rotation Rz around z axis so that image (o, px1) of (o, px) is in the plane xOz with positive x coordinate

• secondly we determine the rotation Ry around y axis so that image (o, px2) of (o, px1) is along x axis with positive coordinate

• at last we determine the rotation Rx around x axis so that image (o, py1) of (o, py) is along y axis with positive coordinate

• we store opposite values of found rotation angles when not null in opposite order (rotations does not commute)

angles are in degree and between 0. and 360.

trim

string_t xlifepp::trim(const string_t &s, const char *delim)

convert “ a b c d e f “ to “a b c d e f”

trims leading and trailing white space from string_t

trimLeading

string_t xlifepp::trimLeading(const string_t &s, const char *delim)

convert “ a b c d e f “ to “a b c d e f “

trims leading white space from string_t

trimTrailing

string_t xlifepp::trimTrailing(const string_t &s, const char *delim)

convert “ a b c d e f “ to “ a b c d e f”

trims trailing white space from string_t

trivialNumbering

template<typename T>
Vector<T> xlifepp::trivialNumbering(const T &n1, const T &n2)

create trivial numbering vector n1, n1+1, …,n2

type2Str

string_t xlifepp::type2Str(ValueType t)

typeArg2Str

string_t xlifepp::typeArg2Str(ArgType ta)

typeFun2Str

string_t xlifepp::typeFun2Str(FunctType tf)

typeOf

template<typename T>
structPair xlifepp::typeOf(const T &v)

umfpackFactorize

template<typename S>
void xlifepp::umfpackFactorize(LargeMatrix<S> &mat)

void xlifepp::umfpackFactorize(TermMatrix &A, TermMatrix &Af)

umfpackSolve

void xlifepp::umfpackSolve(MatrixEntry&, std::vector<VectorEntry*>&, std::vector<VectorEntry*>&, real_t&)

umfpack solver with multiple right hand side (only in scalar representation)

void xlifepp::umfpackSolve(MatrixEntry&, VectorEntry&, VectorEntry&, real_t&)

umfpack solver (only in scalar representation)

SuTermVector xlifepp::umfpackSolve(SuTermMatrix&, const SuTermVector&, bool keepA = false)

solve AX=B using umfpack if available

SuTermVector xlifepp::umfpackSolve(SuTermMatrix &A, const SuTermVector &B, real_t &rcond, bool keepA)

TermVectors xlifepp::umfpackSolve(TermMatrix &A, const std::vector<TermVector> &Bs, bool keepA)

TermVectors xlifepp::umfpackSolve(TermMatrix &A, const std::vector<TermVector> &Bs, real_t &rcond, bool keepA)

TermVector xlifepp::umfpackSolve(TermMatrix &A, const TermVector &B, bool keepA)

TermVector xlifepp::umfpackSolve(TermMatrix &A, const TermVector &B, real_t &rcond, bool keepA)

unCurvatures

inline Vector<real_t> xlifepp::unCurvatures(const Point &p, bool fromParameters, Parameters &pars)

uniformDistribution

void xlifepp::uniformDistribution(complex_t *mat, number_t n = 1, number_t m = 1)

compute a matrix with complex coefficient following an uniform distribution on [0,1[ (using <random> if C11)

void xlifepp::uniformDistribution(complex_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)

compute a matrix with complex coefficient following an uniform distribution on [a,b[ (using <random> if C11)

template<typename T>
std::vector<T> xlifepp::uniformDistribution(number_t n, number_t m, real_t a = 0., real_t b = 1.)

template<typename T>
std::vector<T> xlifepp::uniformDistribution(number_t n, real_t a = 0., real_t b = 1.)

void xlifepp::uniformDistribution(real_t *mat, number_t n = 1, number_t m = 1)

compute a matrix with real coefficient following an uniform distribution on [0,1[ (using <random> if C11)

void xlifepp::uniformDistribution(real_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)

compute a matrix with real coefficient following an uniform distribution on [a,b[ (using <random> if C11)

real_t xlifepp::uniformDistribution(real_t a = 0., real_t b = 1.)

return a sample from an uniform distribution on [a,b[ (using <random> if C11)

template<typename T>
void xlifepp::uniformDistribution(std::vector<T> &mat, number_t n, number_t m, real_t a = 0., real_t b = 1.)

template<typename T>
void xlifepp::uniformDistribution(std::vector<T> &v, real_t a = 0., real_t b = 1.)

uniformDistributionC

void xlifepp::uniformDistributionC(complex_t *mat, number_t n = 1, number_t m = 1)

compute a matrix with complex coefficient following an uniform distribution on [0,1[ (using rand())

void xlifepp::uniformDistributionC(complex_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)

compute a matrix with complex coefficient following an uniform distribution on [a,b[ (using rand())

void xlifepp::uniformDistributionC(real_t *mat, number_t n = 1, number_t m = 1)

compute a matrix with real coefficient following an uniform distribution on [0,1[ (using rand())

void xlifepp::uniformDistributionC(real_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)

compute a matrix with real coefficient following an uniform distribution on [a,b[ (using rand())

real_t xlifepp::uniformDistributionC(real_t a = 0., real_t b = 1.)

return a sample from an uniform distribution on [a,b[ (using rand())

unionOf

Space *xlifepp::unionOf(std::vector<Space*> &sps)

union of subspaces the result, returned as space pointer, may be

union of subspaces

• one subspace of the list if it includes all others

• the root space if the union gives the whole space

• a new subspace

unknownEcName

string_t xlifepp::unknownEcName(const EssentialCondition&)

to create an unknown name associated to an essential condition

updateAcaPlus

template<typename ITV, typename ITAB, typename T>
void xlifepp::updateAcaPlus(ITV itv, ITAB itAb, ITAB itBb, number_t mn, number_t lmax, number_t ijp, bool row, T &piv, number_t &jip, bool updatePiv, std::vector<number_t> *rowcol = nullptr)

updateLeft

OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown&, const Function&, AlgebraicOperator)

update F*Op(u) operation

OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown&, const OperatorOnFunction&, AlgebraicOperator)

update op(F)*Op(u) operation

OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown&, const Value&, AlgebraicOperator)

update V*Op(u) operation

template<typename T>
OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown &opu, const T &val, AlgebraicOperator o)

updateRhs

void xlifepp::updateRhs(TermMatrix&, TermVector&)

prepare rhs B of linear system AX=B (internal tool)

updateRight

OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown&, const Function&, AlgebraicOperator)

update Op(u)*F operation

OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown&, const OperatorOnFunction&, AlgebraicOperator)

update Op(u)*op(F) operation

OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown&, const Value&, AlgebraicOperator)

update Op(u)*V operation

template<typename T>
OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown &opu, const T &val, AlgebraicOperator o)

updateStorage

MatrixStorage *xlifepp::updateStorage(MatrixStorage &stm, const std::vector<number_t> rows, const std::vector<number_t> cols, StorageType st, AccessType at, bool overwrite)

modify MatrixStorage stm to include dense submatrix given by its row and column indices (rows and cols) the new storage is of type (st,at) rows (resp.

update storage for adding dense submatrix given by its row and column indices

cols) has to be a subset of row indices (resp. column indices) of the stm storage if overwrite=true the current storage is overwritten and returned else a new MatrixStorage is returned, the stm storage being not cleared!

uppercase

string_t xlifepp::uppercase(const string_t &s)

convert “AbCdefg” to “ABCDEFG”

returns string_t converted to uppercase

upperDegreeRule

void xlifepp::upperDegreeRule(int degree, const string_t &name, ShapeType sh)

warning message

userBilinearForm

BilinearForm xlifepp::userBilinearForm(const GeomDomain &dom, const Unknown &u, const Unknown &v, BFFunction bffun, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)

BilinearForm xlifepp::userBilinearForm(const GeomDomain &dom, const Unknown &u, const Unknown &v, BFFunctionP bffun, const Parameters &pa, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)

BilinearForm xlifepp::userBilinearForm(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Unknown &v, BFFunction bffun, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)

BilinearForm xlifepp::userBilinearForm(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Unknown &v, BFFunctionP bffun, const Parameters &pa, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)

print utility

interpret as string for print purpose

v4ElementsByRenumbering

Vector<number_t> xlifepp::v4ElementsByRenumbering(ShapeType st, number_t N, const Vector<number_t> &xnum)

construct list of node numbers for each element after renumbering space elements for vizir4 return the list of pair of shape O1 element and node number

valueType

inline ValueType xlifepp::valueType(const complex_t &x)

inline ValueType xlifepp::valueType(const real_t &x)

inline ValueType xlifepp::valueType(const std::vector<complex_t> &x)

inline ValueType xlifepp::valueType(const std::vector<real_t> &x)

inline ValueType xlifepp::valueType(const std::vector<Vector<complex_t>> &x)

inline ValueType xlifepp::valueType(const std::vector<Vector<real_t>> &x)

varName

string_t xlifepp::varName(VariableName v)

vecmat

template<typename K, typename V1_it, typename V2_it>
V2_it xlifepp::vecmat(const Matrix<K> &m, const V1_it it_v1b, const V2_it it_v2b)

template<typename K, typename ITV, typename ITR>
void xlifepp::vecmat(const SparseMatrix<K> &m, const ITV itv, const ITR itr)

template<typename M_it, typename V1_it, typename V2_it>
void xlifepp::vecmat(M_it it_mb, const V1_it it_v1b, const V1_it it_v1e, V2_it it_v2b, V2_it it_v2e)

vector2Array

template<typename K_>
void xlifepp::vector2Array(std::vector<K_> &vec, K_ *target)

Convert vector to an array of K_.

verboseLevel

number_t xlifepp::verboseLevel(const number_t)

sets a maximized value for argument value

Vizir4EltsSides

void xlifepp::Vizir4EltsSides(ShapeType st, number_t N, const vector<number_t> &v, Vector<Vector<number_t>> &V4)

vizir4Export

void xlifepp::vizir4Export(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

vizir4Nature

string_t xlifepp::vizir4Nature(ShapeType st)

vizir4Type

number_t xlifepp::vizir4Type(ShapeType st, number_t order)

voigtToM

OperatorOnUnknown &xlifepp::voigtToM(const Unknown &un)

volumeFrom

Geometry xlifepp::volumeFrom(const Geometry &s, string_t domName)

definition of a geometry 3D from its boundary 2D

definition of a geometry 3D from an union of boundaries 2D

vresize

template<>
inline void xlifepp::vresize(complex_t &t, number_t n)

template<>
inline void xlifepp::vresize(real_t &t, number_t n)

template<typename T>
void xlifepp::vresize(T &t, number_t n = 1)

vsize

template<>
inline number_t xlifepp::vsize(const complex_t &t)

template<>
inline number_t xlifepp::vsize(const real_t &t)

template<typename T>
number_t xlifepp::vsize(const T &t)

vtkExport

void xlifepp::vtkExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

export a split mesh of a domain to vtk format

vtuExport

void xlifepp::vtuExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)

export a split mesh of a domain to vtk format

w1_Ai

inline complex_t xlifepp::w1_Ai(const complex_t &z, DiffOpType d = _id)

2*sqrt(pi)exp(i*pi/6)Ai(t*exp(2i*pi/3))

w2_Ai

inline complex_t xlifepp::w2_Ai(const complex_t &z, DiffOpType d = _id)

2*sqrt(pi)exp(-i*pi/6)Ai(t*exp(-2i*pi/3))

warning

template<typename T>
void xlifepp::warning(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4, typename T5>
void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3, typename T4>
void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2, typename T3>
void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)

template<typename T1, typename T2>
void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)

void xlifepp::warning(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)

shortcut of msg for warning type messages

throw warning messages

wedge_dir

inline complex_t xlifepp::wedge_dir(const complex_t &z, real_t phi, real_t phi0, const complex_t &thetaP, const complex_t &thetaM, const complex_t &coeffP, const complex_t &coeffM, bool istd, const Malyuzhinets &mal)

compute wedge diffraction at (kr,phi) using either Somerfeld paths or Steepest Decent paths Phi: wedge angle , phi0 : incidence angle, tau=pi/2Phi,

        1    /                         cos tau.phi0

u_(kr,phi) = –&#8212; | exp(-ikr.cos z) ————————–&#8212; dz (Dirichlet on both sides) 4i.Phi /path sin tau(phi+z) - sin tau.phi0

1 / cos tau(phi+z) u_(kr,phi) = –&#8212; | exp(-ikr.cos z) ————————–&#8212; dz (Neumann on both sides) 4i.Phi /path sin tau(phi+z) - sin tau.phi0

           1    /                 PsiP(z+phi)PsiM(z+phi)        cos tau.phi_0

u_(kr,phi) = –&#8212; | exp(-ikr.cos z) ——————-&#8212; ————————–&#8212; dz ( Fourier dn(u) - ik.sin thetaP/M u =0 on SigmaP/M) 4i.Phi /path PsiP(phi0)PsiM(phi0) sin tau(phi+z) - sin tau.phi0

with psiP(z)=psi(Phi+z+thetaP-pi/2)psi(Phi+z-thetaP+pi/2) psiM(z)=psi(-Phi+z-thetaM+pi/2)psi(-Phi+z+thetaM-\pi/2)

important notes:

• To deal with Neuman and Dirichlet condition, use Fourier with tethaP=0 and thetaM = -100i for instance

• Computation is hazardous for wedge angle Phi < pi/2 (multiple reflexion)

• Re(thetaMP)<0 (reactive material) induces exponentially growing solutions

• heavy computation when Malyuzhinets function is involved

There are many ways to compute the wedge diffraction depending on

• the paths chosen,

• the Malyuzineths object is passed or not (Fourier mode)

• the number of kr or phi passed (one or few) Note: if Malyuzhinets object is not passed but required, it will be construct internally at each call (additional cost) if more than point given, point loop is parallelized else quadrature loop is parallelized (if OMP available)

wedge_dndirM

inline complex_t xlifepp::wedge_dndirM(const complex_t &z, real_t Phi, real_t phi0)

wedge_dndirP

inline complex_t xlifepp::wedge_dndirP(const complex_t &z, real_t Phi, real_t phi0)

wedge_fou

inline complex_t xlifepp::wedge_fou(const complex_t &z, real_t phi, real_t phi0, const complex_t &thetaP, const complex_t &thetaM, const complex_t &coeffP, const complex_t &coeffM, bool istd, const Malyuzhinets &mal)

wedge_neu

inline complex_t xlifepp::wedge_neu(const complex_t &z, real_t phi, real_t phi0, const complex_t &thetaP, const complex_t &thetaM, const complex_t &coeffP, const complex_t &coeffM, bool istd, const Malyuzhinets &mal)

wedgeCurrentSD

std::vector<complex_t> xlifepp::wedgeCurrentSD(const std::vector<real_t> &krs, real_t Phi, int uplow, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)

wedgeCurrentSD_par

std::vector<complex_t> xlifepp::wedgeCurrentSD_par(const std::vector<real_t> &krs, real_t Phi, int uplow, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)

wedgeCurrentSOM

std::vector<complex_t> xlifepp::wedgeCurrentSOM(const std::vector<real_t> &krs, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)

wedgeDiffractionSD

std::vector<complex_t> xlifepp::wedgeDiffractionSD(const std::vector<real_t> &krs, const std::vector<real_t> &phis, real_t Phi, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)

inline complex_t xlifepp::wedgeDiffractionSD(real_t kr, real_t phi, real_t Phi, real_t phi0, FieldPart fp, real_t kra, BcType bcP, BcType bcM = _undefEcType, complex_t thetaP = 0, complex_t thetaM = 0)

wedgeDiffractionSD_par

std::vector<complex_t> xlifepp::wedgeDiffractionSD_par(const std::vector<real_t> &krs, const std::vector<real_t> &phis, real_t Phi, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)

inline complex_t xlifepp::wedgeDiffractionSD_par(real_t kr, real_t phi, real_t Phi, real_t phi0, FieldPart fp, real_t kra, BcType bcP, BcType bcM = _undefEcType, complex_t thetaP = 0, complex_t thetaM = 0)

wedgeDiffractionSOM

std::vector<complex_t> xlifepp::wedgeDiffractionSOM(const std::vector<real_t> &krs, const std::vector<real_t> &phis, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)

inline complex_t xlifepp::wedgeDiffractionSOM(real_t kr, real_t phi, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM = _undefEcType, complex_t thetaP = 0, complex_t thetaM = 0)

wedgeDirCurrentSD

std::vector<complex_t> xlifepp::wedgeDirCurrentSD(const std::vector<real_t> &krs, real_t Phi, real_t phi0, FieldPart fp, int uplow)

wedgeDirCurrentSOM

std::vector<complex_t> xlifepp::wedgeDirCurrentSOM(const std::vector<real_t> &krs, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM)

where

string_t &xlifepp::where(const string_t &s)

sets a message to tell where we are in the code (shortcut to when push/pop are not set)

whichSide

int_t xlifepp::whichSide(const Point &p, const Point &n, const std::vector<Point> &pts)

determines if a plane splits a set of points

words

string_t xlifepp::words(const bool b)

accessor to words with a boolean

string_t xlifepp::words(const char *key)

accessor to words with a const char* (needed to avoid automatic cast to bool type)

string_t xlifepp::words(const string_t &key)

accessor to words with a string_t

external function to manage localized strings

string_t xlifepp::words(const string_t &key, const int id)

accessor to enumWords

writeLigne

number_t xlifepp::writeLigne(std::ostream &out, const std::string &str, number_t ncar)

Write the string str on the output stream out, limiting the length of all output lines to 80 characters Nota: the length of str is logically assumed to be < 80 characters.

This is not checked since this is always the case when this function is called by the function melExport; moreover, this would not produce any error: the string str would just be written as is on a new line.

ncar is the number of characters previously written on the current line. If the sum of the length of str and ncar does not exceed 80 characters, then str is written at the end of the current line; otherwise str is written on a new line, which then become the (new) current line. The function returns the updated number of characters written on the current line.

zairy

std::complex<double> xlifepp::zairy(const std::complex<double> &z, int id)

Airy function: Ai(z)

zbesselI

std::complex<double> xlifepp::zbesselI(const std::complex<double> &z, double order)

Modified Bessel function of the first kind: I_N(z)

zbesselJ

std::complex<double> xlifepp::zbesselJ(const std::complex<double> &z, double order)

Bessel function of the first kind: J_N(z)

zbesselK

std::complex<double> xlifepp::zbesselK(const std::complex<double> &z, double order)

Modified Bessel function of the second kind: K_N(z)

zbesselY

std::complex<double> xlifepp::zbesselY(const std::complex<double> &z, double order)

Bessel function of the second kind: Y_N(z)

zbiry

inline complex_t xlifepp::zbiry(const complex_t &z, DiffOpType d = _id)

Airy function: Bi(z) or Bi’(z)

std::complex<double> xlifepp::zbiry(const std::complex<double> &z, int id)

Biry function: Bi(z)

zeroCurvatures

inline Vector<real_t> xlifepp::zeroCurvatures(const Point &p, const Point &d, bool fromParameters, Parameters &pars)

zeroLines

static void xlifepp::zeroLines(MatrixEntry *mat, const std::vector<std::vector<std::pair<number_t, number_t>>> &lines)

set to 0 the coefficients of some lines given by storedLines

zeros

inline complex_t xlifepp::zeros(const complex_t &v)

inline real_t xlifepp::zeros(const real_t &v)

zero for scalars

template<typename T>
std::vector<T> xlifepp::zeros(const std::vector<T> &v)

zero for a vector

zexpzE1z

complex_t xlifepp::zexpzE1z(const complex_t&)

return z*exp(z)*E1(z)

zhankel

std::complex<double> xlifepp::zhankel(const std::complex<double> &z, int kind, double order)

Hankel functions of the i-th kind: Hi_N(z)