xlifepp – Functions – F#

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 std::vector<number_t> &nums, const SIDELTMAP &parentEl, ITPARENTS &itpar)#

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