xlifepp – Functions – L#

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

lookfor#

bool xlifepp::lookfor(const string_t BeginSection, FILE *data)#
bool xlifepp::lookfor(const string_t BeginSection, ifstream &data)#
bool xlifepp::lookfor(const string_t BeginSection, std::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)#
On this page