xlifepp – Functions – N#

nabla#

OperatorOnUnknown &xlifepp::nabla(const Unknown &un)#

nabla_x#

OperatorOnKernel &xlifepp::nabla_x(const Kernel&)#: grad_x(k)

OperatorOnKernel &xlifepp::nabla_x(OperatorOnKernel&)#: grad_x(opk)

nabla_y#

OperatorOnKernel &xlifepp::nabla_y(const Kernel&)#: grad_y(k)

OperatorOnKernel &xlifepp::nabla_y(OperatorOnKernel&)#: grad_y(opk)

nablaG#

OperatorOnUnknown &xlifepp::nablaG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)#

nablaS#

OperatorOnUnknown &xlifepp::nablaS(const Unknown &un)#

Navier3d#

Matrix<complex_t> xlifepp::Navier3d(const Point &x, const Point &y, Parameters &pa)#

kernel computation : Phi(k_s; x, y)=1/mu(G(k_s; x, y)*I_3 + 1/k_s^2 * Hess(G(k_s; x, y)-G(k_p; x, y)))

value

Navier3dKernel#

Kernel xlifepp::Navier3dKernel(const real_t &k, const real_t &lambda, const real_t &mu)#: construct a Navier3d kernel

Kernel xlifepp::Navier3dKernel(Parameters& = defaultParameters)#: construct a Navier3d kernel from parameters

Navier3dnxtensornxtimesNGr#

Matrix<complex_t> xlifepp::Navier3dnxtensornxtimesNGr(const Point &x, const Point &y, Parameters &pa)#

kernel computation : NxtensorNx(Phi)

NxtensorNxGr

Navier3dnxtensornxtimestracy#

Matrix<complex_t> xlifepp::Navier3dnxtensornxtimestracy(const Point &x, const Point &y, Parameters &pa)#

kernel computation : NxtensorNxTracy(Phi)

NxtensorNxTracy.

Navier3dTracx#

Matrix<complex_t> xlifepp::Navier3dTracx(const Point &x, const Point &y, Parameters &pa)#

kernel computation : Tracx(Phi)

tracx

Navier3dTracxy#

Matrix<complex_t> xlifepp::Navier3dTracxy(const Point &x, const Point &y, Parameters &pa)#

kernel computation : Tracxy(Phi)

tracx.tracy

Navier3dTracy#

Matrix<complex_t> xlifepp::Navier3dTracy(const Point &x, const Point &y, Parameters &pa)#

kernel computation : Tracy(Phi)

tracy

nbPar#

int xlifepp::nbPar(const ITPARENTS &itpar)#

nbSubDomainsIfScalar#

number_t xlifepp::nbSubDomainsIfScalar(const std::vector<string_t> &sn, number_t nbSubDomains)#

number_t xlifepp::nbSubDomainsIfScalar(string_t sn, number_t nbSubDomains)#

ncross#

OperatorOnFunction &xlifepp::ncross(const Function&)#: n^f

OperatorOnUnknown &xlifepp::ncross(const Unknown &un)#

OperatorOnFunction &xlifepp::ncross(OperatorOnFunction&)#: n^opf

ncross_x#

OperatorOnKernel &xlifepp::ncross_x(const Kernel&)#: nx^k

OperatorOnKernel &xlifepp::ncross_x(OperatorOnKernel&)#: nx^opk

ncross_y#

OperatorOnKernel &xlifepp::ncross_y(const Kernel&)#: ny^k

OperatorOnKernel &xlifepp::ncross_y(OperatorOnKernel&)#: ny^opk

ncrosscurl#

OperatorOnUnknown &xlifepp::ncrosscurl(const Unknown &un)#

ncrosscurl_x#

OperatorOnKernel &xlifepp::ncrosscurl_x(const Kernel&)#: nx^curl_x(k)

OperatorOnKernel &xlifepp::ncrosscurl_x(OperatorOnKernel&)#: nx^curl_x(opk)

ncrosscurl_y#

OperatorOnKernel &xlifepp::ncrosscurl_y(const Kernel&)#: ny^curl_y(k)

OperatorOnKernel &xlifepp::ncrosscurl_y(OperatorOnKernel&)#: ny^curl_y(opk)

ncrossgrad#

OperatorOnUnknown &xlifepp::ncrossgrad(const Unknown &un)#

ncrossncross#

OperatorOnFunction &xlifepp::ncrossncross(const Function&)#: n^(n^f)

OperatorOnUnknown &xlifepp::ncrossncross(const Unknown &un)#

OperatorOnFunction &xlifepp::ncrossncross(OperatorOnFunction&)#: n^(n^opf)

ncrossncross_x#

OperatorOnKernel &xlifepp::ncrossncross_x(const Kernel&)#: nx^nx^k

OperatorOnKernel &xlifepp::ncrossncross_x(OperatorOnKernel&)#: nx^nx^opk

ncrossncross_y#

OperatorOnKernel &xlifepp::ncrossncross_y(const Kernel&)#: ny^ny^k

OperatorOnKernel &xlifepp::ncrossncross_y(OperatorOnKernel&)#: ny^ny^opk

ncrossndot#

OperatorOnUnknown &xlifepp::ncrossndot(const Unknown&)#

OperatorOnFunction &xlifepp::ncrossndot(Function&)#: (n^n)|f

OperatorOnFunction &xlifepp::ncrossndot(OperatorOnFunction&)#: (n^n)|opf

ncrossntimes#

OperatorOnFunction &xlifepp::ncrossntimes(const Function &f)#

OperatorOnUnknown &xlifepp::ncrossntimes(const Unknown &un)#

OperatorOnFunction &xlifepp::ncrossntimes(Function&)#: (n^n)*f

OperatorOnFunction &xlifepp::ncrossntimes(OperatorOnFunction&)#: (n^n)*opf

ncrossrot#

OperatorOnUnknown &xlifepp::ncrossrot(const Unknown &un)#

ncrossrot_x#

OperatorOnKernel &xlifepp::ncrossrot_x(const Kernel&)#: nx^curl_x(k)

OperatorOnKernel &xlifepp::ncrossrot_x(OperatorOnKernel&)#: nx^curl_x(opk)

ncrossrot_y#

OperatorOnKernel &xlifepp::ncrossrot_y(const Kernel&)#: ny^curl_y(k)

OperatorOnKernel &xlifepp::ncrossrot_y(OperatorOnKernel&)#: ny^curl_y(opk)

ndiv#

OperatorOnUnknown &xlifepp::ndiv(const Unknown &un)#

ndiv_x#

OperatorOnKernel &xlifepp::ndiv_x(const Kernel&)#: nx*div_x(k)

OperatorOnKernel &xlifepp::ndiv_x(OperatorOnKernel&)#: nx*div_x(opk)

ndiv_y#

OperatorOnKernel &xlifepp::ndiv_y(const Kernel&)#: ny*div_y(k)

OperatorOnKernel &xlifepp::ndiv_y(OperatorOnKernel&)#: ny*div_y(opk)

ndot#

OperatorOnFunction &xlifepp::ndot(const Function&)#: n|f

OperatorOnUnknown &xlifepp::ndot(const Unknown &un)#

OperatorOnFunction &xlifepp::ndot(OperatorOnFunction&)#: n|opf

ndot_x#

OperatorOnKernel &xlifepp::ndot_x(const Kernel&)#: nx|k

OperatorOnKernel &xlifepp::ndot_x(OperatorOnKernel&)#: nx|opk

ndot_y#

OperatorOnKernel &xlifepp::ndot_y(const Kernel&)#: ny|k

OperatorOnKernel &xlifepp::ndot_y(OperatorOnKernel&)#: ny|opk

ndotgrad#

OperatorOnUnknown &xlifepp::ndotgrad(const Unknown &un)#

ndotgrad_x#

OperatorOnKernel &xlifepp::ndotgrad_x(const Kernel&)#: nx|grad_x(k)

OperatorOnKernel &xlifepp::ndotgrad_x(OperatorOnKernel&)#: nx|grad_x(opk)

ndotgrad_y#

OperatorOnKernel &xlifepp::ndotgrad_y(const Kernel&)#: ny|grad_y(k)

OperatorOnKernel &xlifepp::ndotgrad_y(OperatorOnKernel&)#: ny|grad_y(opk)

newSkyline#

template<class M_> M_ *xlifepp::newSkyline(const M_ *mat_p)#

This function allocates a new matrix, equal to the input matrix but with a skyline storage.

Create a new matrix (especially a LargeMatrix) with a skyline storage.

The new matrix can then be factorized using one of the internal factorization algorithms available in XLiFE++, such as LDLt, LDL* or LU.

newton#

template<typename T> real_t xlifepp::newton(T (*f)(const T&), T (*fp)(const T&), T &x0, number_t niter = 100, real_t tol = theTolerance)#

nlConj#

inline complex_t xlifepp::nlConj(const complex_t &t)#

inline real_t xlifepp::nlConj(const real_t &t)#

nodesDim#

number_t xlifepp::nodesDim(const Geometry &g)#

noEvenDegreeRule#

void xlifepp::noEvenDegreeRule(int degree, const string_t &name, ShapeType sh)#: warning message

nonSeparatingEdge#

std::pair<number_t, number_t> xlifepp::nonSeparatingEdge(const std::vector<Point> &p)#

determines one edge of the polygon defined by its list of vertices that do not separate the polygon

determines an edge of a polygon so that the whole polygon is on the same side

norm#

inline real_t xlifepp::norm(const complex_t &v)#

inline real_t xlifepp::norm(const real_t &v)#: norm of scalars

template<typename T> real_t xlifepp::norm(const std::vector<T> &v)#: norm of vector

real_t xlifepp::norm(const TermVector &tv, number_t l = 2)#: vector norm

real_t xlifepp::norm(const VectorEntry&, number_t l = 2)#: norm of Vector entry (default l2)

norm1#

real_t xlifepp::norm1(const SuTermVector&)#: l1 vector SuTermVector norm

real_t xlifepp::norm1(const TermVector &vt)#: l1 TermVector norm

template<typename T> real_t xlifepp::norm1(const Vector<T> &v)#

real_t xlifepp::norm1(const VectorEntry&)#: l1 vector VectorEntry norm

norm2#

inline real_t xlifepp::norm2(const complex_t&)#

template<typename T> inline real_t xlifepp::norm2(const LargeMatrix<T> &A)#

real_t xlifepp::norm2(const Matrix<complex_t>&)#

real_t xlifepp::norm2(const Matrix<Matrix<complex_t>>&)#

real_t xlifepp::norm2(const Matrix<Matrix<real_t>>&)#

real_t xlifepp::norm2(const Matrix<real_t>&)#

real_t xlifepp::norm2(const Point&)#: returns the square distance between 2 points

inline real_t xlifepp::norm2(const real_t&)#

real_t xlifepp::norm2(const SuTermVector&)#: l2 vector SuTermVector norm (quadratic norm)

inline real_t xlifepp::norm2(const TermMatrix &A)#

real_t xlifepp::norm2(const TermVector &vt)#: l2 TermVector norm (quadratic norm)

template<typename T> real_t xlifepp::norm2(const Vector<T> &v)#: norm of Vector, extern forms

real_t xlifepp::norm2(const VectorEntry&)#: l2 vector VectorEntry (quadratic norm)

normal_Piecewise#

inline Vector<real_t> xlifepp::normal_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

normalBoxMuller#

real_t xlifepp::normalBoxMuller(real_t mu = 0., real_t sigma = 1.)#: normal distribution (mu,sigma) using Box Muller method (using rand())

normalDistribution#

void xlifepp::normalDistribution(complex_t *mat, number_t n = 1, number_t m = 1)#: compute a complex Gaussian matrix normal distribution (0,1) (using <random> if C11)

void xlifepp::normalDistribution(complex_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)#: compute a complex Gaussian matrix normal distribution (mu,sigma) (using <random> if C11)

template<typename T> std::vector<T> xlifepp::normalDistribution(number_t n, number_t m, real_t mu = 0., real_t sigma = 1.)#

template<typename T> std::vector<T> xlifepp::normalDistribution(number_t n, real_t mu = 0., real_t sigma = 1.)#

void xlifepp::normalDistribution(real_t *mat, number_t n = 1, number_t m = 1)#: compute a Gaussian matrix normal distribution (0,1) (using <random> if C11)

void xlifepp::normalDistribution(real_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)#: compute a Gaussian matrix normal distribution (mu,sigma) (using <random> if C11)

real_t xlifepp::normalDistribution(real_t mu = 0., real_t sigma = 1., GaussianGenerator gg = _MarsagliaGenerator)#: return a sample from normal distribution (mu,sigma) (using <random> if C11)

template<typename T> void xlifepp::normalDistribution(std::vector<T> &mat, number_t n, number_t m, real_t mu = 0., real_t sigma = 1.)#

template<typename T> void xlifepp::normalDistribution(std::vector<T> &v, real_t mu = 0., real_t sigma = 1.)#

normalDistributionC#

void xlifepp::normalDistributionC(complex_t *mat, GaussianGenerator gg, number_t n = 1, number_t m = 1)#: compute a complex Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(complex_t *mat, number_t n = 1, number_t m = 1)#: compute a complex Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(complex_t *mat, real_t mu, real_t sigma, GaussianGenerator gg, number_t n = 1, number_t m = 1)#: compute a complex Gaussian matrix normal distribution (mu,sigma) (using rand())

void xlifepp::normalDistributionC(complex_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)#: compute a complex Gaussian matrix normal distribution (mu,sigma) (using rand())

void xlifepp::normalDistributionC(real_t *mat, GaussianGenerator gg, number_t n = 1, number_t m = 1)#: compute a Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(real_t *mat, number_t n = 1, number_t m = 1)#: compute a Gaussian matrix normal distribution (0,1) (using rand())

void xlifepp::normalDistributionC(real_t *mat, real_t mu, real_t sigma, GaussianGenerator gg, number_t n = 1, number_t m = 1)#: compute a Gaussian matrix normal distribution (mu,sigma) (using rand())

void xlifepp::normalDistributionC(real_t *mat, real_t mu, real_t sigma, number_t n = 1, number_t m = 1)#: compute a Gaussian matrix normal distribution (mu,sigma) (using rand())

real_t xlifepp::normalDistributionC(real_t mu = 0., real_t sigma = 1., GaussianGenerator gg = _MarsagliaGenerator)#: return a sample from normal distribution (mu,sigma) (using rand())

normalizeEigenVectors#

template<typename T> MatrixEigenDense<T> xlifepp::normalizeEigenVectors(const MatrixEigenDense<T> &eigVecs)#

normalMarsaglia#

double xlifepp::normalMarsaglia(real_t mu = 0., real_t sigma = 1.)#: normal distribution (mu,sigma) using Marsaglia method (using rand())

normalsOn#

TermVector xlifepp::normalsOn(GeomDomain &dom, const Unknown &u)#: compute normals of a side domain using interpolation given by an unknown

normalVectorFromParameters#

inline Vector<real_t> &xlifepp::normalVectorFromParameters(const Parameters &pa)#: extract normal vector from Parameters

norminfty#

inline real_t xlifepp::norminfty(const complex_t &z)#

template<typename T> inline real_t xlifepp::norminfty(const LargeMatrix<T> &A)#

real_t xlifepp::norminfty(const Matrix<complex_t>&)#

real_t xlifepp::norminfty(const Matrix<Matrix<complex_t>>&)#

real_t xlifepp::norminfty(const Matrix<Matrix<real_t>>&)#

real_t xlifepp::norminfty(const Matrix<real_t>&)#

inline real_t xlifepp::norminfty(const real_t &r)#

real_t xlifepp::norminfty(const SuTermVector&)#: l_infinite SuTermVector norm (sup norm)

inline real_t xlifepp::norminfty(const TermMatrix &A)#

real_t xlifepp::norminfty(const TermVector &vt)#: l_infinite TermVector norm (sup norm)

template<typename T> real_t xlifepp::norminfty(const Vector<T> &v)#

real_t xlifepp::norminfty(const VectorEntry&)#: l_infinite VectorEntry (sup norm)

ntimes#

OperatorOnFunction &xlifepp::ntimes(const Function&)#: n*f

OperatorOnFunction &xlifepp::ntimes(OperatorOnFunction&)#: n*opf

ntimes_x#

OperatorOnKernel &xlifepp::ntimes_x(const Kernel&)#: nx*k

OperatorOnKernel &xlifepp::ntimes_x(OperatorOnKernel &opk)#: nx*opk

ntimes_y#

OperatorOnKernel &xlifepp::ntimes_y(const Kernel&)#: ny*k

OperatorOnKernel &xlifepp::ntimes_y(OperatorOnKernel &opk)#: ny*opk

ntimesndot#

OperatorOnUnknown &xlifepp::ntimesndot(const Unknown &un)#

numberingConversion#

template<class ST_> const vector<number_t> xlifepp::numberingConversion(const number_t order)#

The following function returns a vector giving the correspondence between the two numberings of the points of the Lagrange mesh of order k over the reference element (triangle or quadrangle).

The following function returns a vector giving the correspondence between the two numberings of the points of the Lagrange mesh of order k over the reference element (tetrahedron or hexahedron).

Provided V is the returned vector, if i denotes the rank of a point in XLiFE++, then the corresponding point is V[i] in class subdivision::TriangleMesh or subdivision::QuadrangleMesh, referred to as xxxMesh in the following.

Provided V is the returned vector, if i denotes the rank of a point in XLiFE++ then the corresponding point is V[i] in class subdivision::TetrahedronMesh or subdivision::HexahedronMesh, referred to as xxxMesh in the following.

numberOfCols#

number_t xlifepp::numberOfCols(const complex_t &v)#

template<typename T> number_t xlifepp::numberOfCols(const Matrix<T> &m)#

number_t xlifepp::numberOfCols(const real_t &v)#

numberOfRows#

number_t xlifepp::numberOfRows(const complex_t &v)#

template<typename T> number_t xlifepp::numberOfRows(const Matrix<T> &m)#

number_t xlifepp::numberOfRows(const real_t &v)#

numberOfThreads#

number_t xlifepp::numberOfThreads(int n)#

manage the number of threads in OpenMP if n==0 set to the maximum of number of threads if n >0 set the number of threads to n if n==-1 return the number of threads (default) if omp is not available, always return 1

if omp is available, set or get the number of threads (default)

numToDim#

inline dimen_t xlifepp::numToDim(number_t n, string_t loc = "?")#

numToInt#

inline int_t xlifepp::numToInt(number_t n, string_t loc = "?")#

nx#

OperatorOnUnknown &xlifepp::nx(const Unknown &un)#

nxcrossny_cross#

OperatorOnKernel &xlifepp::nxcrossny_cross(const Kernel&)#: (nx^ny)^k

OperatorOnKernel &xlifepp::nxcrossny_cross(OperatorOnKernel&)#

(nx^ny)^opk

Parameters:: opk – (nx.ny).opk

nxcrossny_dot#

OperatorOnKernel &xlifepp::nxcrossny_dot(const Kernel&)#: (nx^ny).k

OperatorOnKernel &xlifepp::nxcrossny_dot(OperatorOnKernel&)#

(nx^ny).opk

Parameters:: opk – (nx.ny).opk

nxdotny_times#

OperatorOnKernel &xlifepp::nxdotny_times(const Kernel&)#: (nx.ny)*k

OperatorOnKernel &xlifepp::nxdotny_times(OperatorOnKernel&)#

(nx.ny)*opk

Parameters:: opk – (nx.ny)*opk

nxtensornxtimesNGr#

OperatorOnKernel &xlifepp::nxtensornxtimesNGr(const Kernel&)#: (nxtensornx)*Id(k)

nxtensornxtimestrac_y#

OperatorOnKernel &xlifepp::nxtensornxtimestrac_y(const Kernel&)#: (nxtensornx)*trac_y(k)

nycrossnx_cross#

OperatorOnKernel &xlifepp::nycrossnx_cross(const Kernel&)#: (ny^ny)^k

OperatorOnKernel &xlifepp::nycrossnx_cross(OperatorOnKernel&)#

(ny^nx)^opk

Parameters:: opk – (nx.ny).opk

nycrossnx_dot#

OperatorOnKernel &xlifepp::nycrossnx_dot(const Kernel&)#: (ny^nx).k

OperatorOnKernel &xlifepp::nycrossnx_dot(OperatorOnKernel&)#

(ny^nx).opk

Parameters:: opk – (nx.ny).opk