xlifepp – Functions – B#

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