xlifepp – Functions – A

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)