xlifepp – Functions – C#

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