xlifepp – Functions – M#

makeParList#

std::vector<Parameter> xlifepp::makeParList(int nbpar, ...)#

mal_integrand#

complex_t xlifepp::mal_integrand(real_t t, Parameters &pars)#: integrand at (t,z), extern call, pars = (object, z)

mapNL#

void xlifepp::mapNL(GeomMapData *mapP1, GeomMapData &gmap, Point &X, Point &x, real_t &eltdif, Vector<real_t> &n, bool withn)#

mapShapeValues#

inline void xlifepp::mapShapeValues(RefElement &refElt, MeshElement &melt, GeomMapData &mapdata, bool mapsh, FEMapType femt, bool rotsh, number_t ord, bool changeSign, const Vector<real_t> *sign, dimen_t dimfun, dimen_t &dimfunp, const ShapeValues &sh, ShapeValues &shmap)#

mapTo#

TermVector xlifepp::mapTo(const TermVector &v, const GeomDomain &dom, const Unknown &u, bool useNearest, bool errorOnOutDom, Function *fmap, real_t tol)#

materialIdFromParameters#

inline number_t xlifepp::materialIdFromParameters(Parameters &pars)#

matmat#

template<typename A_it, typename B_it, typename R_it> void xlifepp::matmat(A_it it_ma, const dimen_t nbk, B_it it_mb, const dimen_t nbr, const dimen_t nbc, R_it it_mr)#

matvec#

template<typename K, typename V1_it, typename V2_it> V2_it xlifepp::matvec(const Matrix<K> &m, const V1_it it_v1b, const V2_it it_v2b)#

template<typename K, typename ITV, typename ITR> void xlifepp::matvec(const SparseMatrix<K> &m, const ITV itv, const ITR itr)#

template<typename M_it, typename V1_it, typename V2_it> void xlifepp::matvec(M_it it_mb, const V1_it it_v1b, const V1_it it_v1e, V2_it it_v2b, V2_it it_v2e)#

maxAbsVal#

inline complex_t xlifepp::maxAbsVal(const complex_t&)#

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

template<typename K> complex_t xlifepp::maxAbsVal(const Vector<K> &u)#: return the value (in complex) of component being the largest one in absolute value

maxDegreeRule#

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

maxElementTpl#

template<typename T_iterator> T_iterator xlifepp::maxElementTpl(T_iterator b, T_iterator e)#: returns iterator to first occurrence of maximum absolute magnitude in stl container

maxSeparator#

int_t xlifepp::maxSeparator(const Point &p, const Point &q, int &c, real_t &s)#: separation function used by KdTree

maxTpl#

template<typename T, typename U> T xlifepp::maxTpl(const T &a, const U &b)#: returns maximum of 2 values

template<typename T, typename U, typename V> T xlifepp::maxTpl(const T &a, const U &b, const V &c)#: returns maximum of 3 values

Maxwell3d#

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

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

value

Maxwell3dCurlx#

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

kernel computation: Curlx(IG_t)

curlx

Maxwell3dCurlxy#

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

kernel computation: CurlxCurly(IG_t)

curlx.curly

Maxwell3dCurly#

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

kernel computation: Curly(IG_t)

curly

Maxwell3dDivx#

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

kernel computation: Divx(IG_t)

divx

Maxwell3dDivxy#

complex_t xlifepp::Maxwell3dDivxy(const Point &x, const Point &y, Parameters &pa)#

kernel computation: DivxDivy(IG_t)

divx.divy

Maxwell3dDivy#

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

kernel computation: Divy(IG_t)

divy

Maxwell3dKernel#

Kernel xlifepp::Maxwell3dKernel(const complex_t &k, const real_t &t = 0)#: construct a Maxwell3d kernel from complex k

Kernel xlifepp::Maxwell3dKernel(const real_t &k, const real_t &t = 0)#: construct a Maxwell3d kernel from real k

Kernel xlifepp::Maxwell3dKernel(Parameters& = defaultParameters)#: construct a Maxwell3d kernel from parameters

mean#

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

OperatorOnUnknown &xlifepp::mean(OperatorOnUnknown &opu)#

measure#

inline real_t xlifepp::measure(const GeomDomain &g)#: measure (length, surface or volume) of Domain

merge#

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 20 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 19 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 18 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 17 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 16 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 15 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 14 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 13 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 12 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 11 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 10 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 9 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 8 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 7 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 6 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 5 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 4 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, const GeomDomain&, S_ name)#: merge 3 geometrical domains (true union of elements)

template<typename S_> GeomDomain &xlifepp::merge(const GeomDomain&, const GeomDomain&, S_ name)#: merge 2 geometrical domains (true union of elements)

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, bool mergeSharedBoundary = true, const string_t &name = "#Omega")#

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, const Mesh &m3, bool mergeSharedBoundary = true, const string_t &name = "#Omega")#

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, const Mesh &m3, const Mesh &m4, bool mergeSharedBoundary = true, const string_t &name = "#Omega")#

inline Mesh xlifepp::merge(const Mesh &m1, const Mesh &m2, const Mesh &m3, const Mesh &m4, const Mesh &m5, bool mergeSharedBoundary = true, const string_t &name = "#Omega")#

template<typename S_> GeomDomain &xlifepp::merge(const std::vector<const GeomDomain*> &doms, S_ name)#

merge some geometrical domains (true union of elements) GeomDomains must be MeshDomain of same dimension

merge some geometrical domains (true union of elements)

Mesh xlifepp::merge(const std::vector<const Mesh*> &ms, bool mergeSharedBoundary = true, const string_t &name = "#Omega")#: merge meshes of same dimension

template<typename S_> GeomDomain &xlifepp::merge(const std::vector<GeomDomain*> &doms, S_ name)#

merge some geometrical domains (true union of elements) GeomDomains must be MeshDomain of same dimension

merge some geometrical domains (true union of elements), non const version

TermVector xlifepp::merge(const TermVector&, const TermVector&)#: merge two termvectors, preserving values of first one when common dofs

mergeConstraints#

std::map<const Unknown*, Constraints*> xlifepp::mergeConstraints(std::vector<Constraints*> &constraints)#

merge constraints systems (if more than one conditions) it takes as input a vector of Constraints (each corresponding to an essential condition) and produces a map of Constraints indexed by unknown with two cases:

merge constraints

Case of uncoupled unknowns (u1/v1, u2/v2 referred to same unknown u/v), u and v are not coupled by constraints u1 u2 v1 v2 —————–— u1 u2 v1 v2 c1 |cu1 0 0 0 | | f1 ——-— ——— c2 | 0 cu2 0 0 | = | f2 ==> Cu = |cu1 0 | = fu= | f1 Cv = |cv1 cv2| = fv= | f3 c3 | 0 cv1 cv2 | | f3 | 0 cu2 | | f2 ———

The merging process involving u1, u2 referring to same unknown u produces

Constraints object where common dofs are merged One Constraints object for each unknown is created and returned

Case of coupled unknowns (u1/v1, u2/v2 referred to same unknown u/v), u and v are coupled at least by one constraint u1 u2 v1 v2 —————-— u v c1 |cu1 0 0 0 | = | f1 ——— c2 | 0 cu2 cv1 cv2 | | f2 ==> |Cu Cv | = f

A global

Constraints matrix is created and returned (indexed by 0)

NOTE: when merging some Constraints in a new one the old ones are deleted by this function

mergeSubspaces#

Space *xlifepp::mergeSubspaces(Space *&sp1, Space *&sp2, bool newSubspaces)#

merge subspaces given by a list of Space pointer the union is allowed only for subspaces of same root space this function may return the root space, one of the subspaces or a new subspace if newSubspaces is true, new subspaces with union as parent are created and return as space pointers

merge two subspaces

Space *xlifepp::mergeSubspaces(std::vector<Space*> &sps, bool newSubspaces = false)#: merge a list of subspaces

mergeSuTermMatrix#

SuTermMatrix *xlifepp::mergeSuTermMatrix(const std::list<SuTermMatrix*>&)#: merge SuTerMatrix’s referring to the same vector unknown

mergeSuTermVector#

SuTermVector *xlifepp::mergeSuTermVector(const std::list<SuTermVector*>&)#: merge blocks with components of the same unknown

message#

template<typename T> string_t xlifepp::message(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)#: templated message functions (shortcuts avoiding the use of MsgData object)

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, const T10 &v10, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2> string_t xlifepp::message(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)#

string_t xlifepp::message(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)#

main function to throw an error/warning/info message where

build formated message

exemple: to throw the internal error with an int msgId and a string s paramaters data << s; msg(“msg_undef”, data, errInternal,_error);

NOTE that MsgData structure is cleared after call. data and errInternal,_error have default values theMessageData and theMessages_p

Parameters:

msgIds – the string id of a message in this collection
msgData – a data object containing the message parameters
msgSrc – pointer to an error message formats collection

minElementTpl#

template<typename T_iterator> T_iterator xlifepp::minElementTpl(T_iterator b, T_iterator e)#: returns iterator to first occurrence of minimum absolute magnitude in stl container

minTpl#

template<typename T, typename U> T xlifepp::minTpl(const T &a, const U &b)#: returns minimum of 2 values

template<typename T, typename U, typename V> T xlifepp::minTpl(const T &a, const U &b, const V &c)#: returns minimum of 3 values

mixedProduct#

real_t xlifepp::mixedProduct(const Point&, const Point&, const Point&)#: returns the mixed product (AxB).C

msg#

void xlifepp::msg(const string_t &msgIds, MsgData &msgData, Messages *msgSrc, MsgType &msgType)#: throw messages

void xlifepp::msg(const string_t &msgIds, MsgData &msgData, Messages *msgSrc, MsgType msgType = _info)#: general message handler

msgInit#

void xlifepp::msgInit(const string_t &msgPath, std::ofstream &out)#

initialization procedure for messages handling

initialization of engine for messages handling

mshAsciiExport#

void xlifepp::mshAsciiExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)#

mshBinExport#

void xlifepp::mshBinExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)#

mshExport#

void xlifepp::mshExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)#: export a split mesh of a domain to msh format

mshType#

number_t xlifepp::mshType(ShapeType sht, number_t order)#: returns the id msh number of a shape, according to the finite elements order

mtlbExport#

void xlifepp::mtlbExport(const GeomDomain &dom, const std::vector<Point> &coords, const splitvec_t &elementsInfo, std::ostream &out)#: export a split mesh of a domain to Matlab - Octave format

void xlifepp::mtlbExport(const GeomDomain &dom, const vector<Point> &coords, const vector<pair<ShapeType, vector<number_t>>> &elementsInfo, std::ostream &out)#

multFactMatrixVector#

template<typename T, typename V, typename R> void xlifepp::multFactMatrixVector(const LargeMatrix<T> &mat, const std::vector<V> &vec, std::vector<R> &res)#: product with factorized matrix no permutation: L*U*X or L*D*Lt*X or (L*D*L*)*X row permutation (PA=LU) : inv(P)*L*U*X or inv(P)*L*D*Lt*X or inv(P)*(L*D*L*)*X col permutation (AQ=LU) : L*U*inv(Q)*X or L*D*Lt*inv(Q)*X or (L*D*L*)*inv(Q)*X row and col permutation (PAQ=LU) : inv(P)*L*U*inv(Q)*X or inv(P)*L*D*Lt*inv(Q)*X or inv(P)*(L*D*L*)*inv(Q)*X called by multMatrixVector functions

multInverMatrixVector#

template<typename S1, typename S2> void xlifepp::multInverMatrixVector(const LargeMatrix<S1> &mat, std::vector<S2> &vec, std::vector<typename Conditional<NumTraits<S1>::IsComplex, S1, S2>::type> &res, FactorizationType fac)#

multMatMat#

template<typename K1, typename K2> void xlifepp::multMatMat(const MatrixEigenDense<K1> &mat1, const MatrixEigenDense<K2> &mat2, MatrixEigenDense<typename Conditional<NumTraits<K1>::IsComplex, K1, K2>::type> &res)#

multMatrix#

template<typename T> ApproximateMatrix<T> &xlifepp::multMatrix(ApproximateMatrix<T> &A, ApproximateMatrix<T> &B, ApproximateMatrix<T> &AB)#: ApproximateMatrix * ApproximateMatrix -> ApproximateMatrix.

template<typename T> ApproximateMatrix<T> &xlifepp::multMatrix(ApproximateMatrix<T> &A, LargeMatrix<T> &L, ApproximateMatrix<T> &AL)#: ApproximateMatrix * LargeMatrix -> ApproximateMatrix.

template<typename T> ApproximateMatrix<T> &xlifepp::multMatrix(LargeMatrix<T> &L, ApproximateMatrix<T> &A, ApproximateMatrix<T> &LA)#: LargeMatrix * ApproximateMatrix -> ApproximateMatrix.

template<typename T> LowRankMatrix<T> &xlifepp::multMatrix(LargeMatrix<T> &L, LowRankMatrix<T> &A, LowRankMatrix<T> &AL)#: product of a LargeMatrix and a LowRankMatrix

template<typename T> LowRankMatrix<T> &xlifepp::multMatrix(LowRankMatrix<T> &A, LargeMatrix<T> &L, LowRankMatrix<T> &AL)#: product of a LowRankMatrix and a LargeMatrix

template<typename T> LowRankMatrix<T> &xlifepp::multMatrix(LowRankMatrix<T> &A, LowRankMatrix<T> &B, LowRankMatrix<T> &AB)#: product of two LowRankMatrix’s

multMatrixMatrix#

template<typename SA, typename SB, typename SR> void xlifepp::multMatrixMatrix(const LargeMatrix<SA> &mA, const LargeMatrix<SB> &mB, LargeMatrix<SR> &mR)#: extern template product matrix*matrix the storage of the resulting matrix is ALWAYS dense there is no chance to get a sparse matrix except in case of product with a diagonal matrix where the storage is unchanged

template<typename SA, typename SB, typename SR> void xlifepp::multMatrixMatrix(const LargeMatrix<SA> &mA, const std::vector<SB> &mB, LargeMatrix<SR> &mR)#

template<typename SA, typename SB, typename SR> void xlifepp::multMatrixMatrix(const std::vector<SA> &mA, const LargeMatrix<SB> &mB, LargeMatrix<SR> &mR)#

multMatrixScalar#

LargeMatrix<complex_t> xlifepp::multMatrixScalar(const LargeMatrix<complex_t> &mat, const real_t v)#

Multiple a complex Matrix with real scalar The result matrix will point to the same storage.

Parameters:

mat – complex matrix
v – real scalar

Returns:

result matrix which share the same storage.

LargeMatrix<complex_t> xlifepp::multMatrixScalar(const LargeMatrix<real_t> &mat, const complex_t v)#

Multiple a real Matrix with complex scalar The result matrix will point to the same storage.

Parameters:

mat – real matrix
v – complex scalar

Returns:

complex matrix which share the same storage.

template<typename T> LargeMatrix<T> xlifepp::multMatrixScalar(const LargeMatrix<T> &mat, const T v)#

Multiple a largeMatrix with a scalar The result matrix will point to the same storage.

Parameters:

mat – matrix
v – scalar

Returns:

result matrix which shares the same storage.

multMatrixVector#

template<typename T, typename I> Vector<T> xlifepp::multMatrixVector(const HMatrix<T, I> &h, const Vector<T> &x)#: hmatrix vector product

void xlifepp::multMatrixVector(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec, std::vector<complex_t> &res)#

void xlifepp::multMatrixVector(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec, std::vector<Vector<complex_t>> &res)#

void xlifepp::multMatrixVector(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec, std::vector<Vector<complex_t>> &res)#

template<typename T> void xlifepp::multMatrixVector(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec, std::vector<Vector<T>> &res)#: templated mat<Matrix<T> > * vec<Vector<T> >

void xlifepp::multMatrixVector(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec, std::vector<complex_t> &res)#

template<typename T> void xlifepp::multMatrixVector(const LargeMatrix<T> &mat, const std::vector<T> &vec, std::vector<T> &res)#: templated mat<T> * vec<T>

template<typename T, typename V, typename R> void xlifepp::multMatrixVector(const LargeMatrix<T> &mat, V *vp, R *rp)#: templated mat<T> * vec<V> (pointer form)

template<typename K> void xlifepp::multMatrixVector(const Matrix<K> &m, const Vector<K> &v, Vector<K> &mv)#

void xlifepp::multMatrixVector(const MatrixEntry&, const VectorEntry&, VectorEntry&)#: matrix * vector

TermVector xlifepp::multMatrixVector(const SymbolicTermMatrix &S, const TermVector &X)#

TermVector &xlifepp::multMatrixVector(const TermMatrix&, const TermVector&, TermVector&)#: product TermMatrix * TermVector

multMatVecLargeMatrixAdapter#

template<typename Scalar, typename ScalarTypeX, typename MatrixType> void xlifepp::multMatVecLargeMatrixAdapter(const LargeMatrixAdapter<MatrixType, Scalar> &m, const MultiVec<ScalarTypeX> &x, MultiVec<typename Conditional<NumTraits<Scalar>::IsComplex, Scalar, ScalarTypeX>::type> &y)#

multScalarThenAssign#

template<typename T> void xlifepp::multScalarThenAssign(TermVector &tv, const T &t)#

operation U*=t

p*=t

template<typename K, typename KK> void xlifepp::multScalarThenAssign(Vector<K> &v, const KK &x)#

void xlifepp::multScalarThenAssign(Vector<real_t> &v, const complex_t &c)#

multVectorFactMatrix#

template<typename T, typename V, typename R> void xlifepp::multVectorFactMatrix(const LargeMatrix<T> &mat, const std::vector<V> &vec, std::vector<R> &res)#: product with factorized matrix A=LU, or A=LDLt or A =LDL* no permutation: X*L*U = (Ut*Lt*Xt)t row permutation (PA=LU) : X*inv(P)*L*U = Ut*Lt*inv(P)t*Xt = Ut*Lt*P*Xt col permutation (AQ=LU) : X*L*U*inv(Q) = inv(Q)t*Ut*Lt*Xt = Q*Ut*Lt*Xt row and col permutation (PAQ=LU) : X*inv(P)*L*U*inv(Q) = inv(Q)t*Ut*Lt*inv(P)t*Xt = Q*Ut*Lt*P*Xt called by multMatrixVector

multVectorMatrix#

void xlifepp::multVectorMatrix(const LargeMatrix<complex_t> &mat, const std::vector<real_t> &vec, std::vector<complex_t> &res)#

void xlifepp::multVectorMatrix(const LargeMatrix<Matrix<complex_t>> &mat, const std::vector<Vector<real_t>> &vec, std::vector<Vector<complex_t>> &res)#

void xlifepp::multVectorMatrix(const LargeMatrix<Matrix<real_t>> &mat, const std::vector<Vector<complex_t>> &vec, std::vector<Vector<complex_t>> &res)#

template<typename T> void xlifepp::multVectorMatrix(const LargeMatrix<Matrix<T>> &mat, const std::vector<Vector<T>> &vec, std::vector<Vector<T>> &res)#

void xlifepp::multVectorMatrix(const LargeMatrix<real_t> &mat, const std::vector<complex_t> &vec, std::vector<complex_t> &res)#

template<typename T> void xlifepp::multVectorMatrix(const LargeMatrix<T> &mat, const std::vector<T> &vec, std::vector<T> &res)#

template<typename T, typename V, typename R> void xlifepp::multVectorMatrix(const LargeMatrix<T> &mat, V *vp, R *rp)#: templated vec<V> * mat<T> (pointer form)

void xlifepp::multVectorMatrix(const MatrixEntry&, const VectorEntry&, VectorEntry&)#: vector * matrix

void xlifepp::multVectorMatrix(const std::vector<complex_t> &vec, const LargeMatrix<real_t> &mat, std::vector<complex_t> &res)#

void xlifepp::multVectorMatrix(const std::vector<real_t> &vec, const LargeMatrix<complex_t> &mat, std::vector<complex_t> &res)#

template<typename T> void xlifepp::multVectorMatrix(const std::vector<T> &vec, const LargeMatrix<T> &mat, std::vector<T> &res)#

void xlifepp::multVectorMatrix(const std::vector<Vector<complex_t>> &vec, const LargeMatrix<Matrix<real_t>> &mat, std::vector<Vector<complex_t>> &res)#

void xlifepp::multVectorMatrix(const std::vector<Vector<real_t>> &vec, const LargeMatrix<Matrix<complex_t>> &mat, std::vector<Vector<complex_t>> &res)#

template<typename T> void xlifepp::multVectorMatrix(const std::vector<Vector<T>> &vec, const LargeMatrix<Matrix<T>> &mat, std::vector<Vector<T>> &res)#

TermVector &xlifepp::multVectorMatrix(const TermMatrix&, const TermVector&, TermVector&)#: product TermVector * TermMatrix

TermVector &xlifepp::multVectorMatrix(const TermVector&, const TermMatrix&, TermVector&)#: product TermVector * TermMatrix

TermVector xlifepp::multVectorMatrix(const TermVector &X, const SymbolicTermMatrix &S)#

template<typename K> void xlifepp::multVectorMatrix(const Vector<K> &v, const Matrix<K> &m, Vector<K> &mv)#

void xlifepp::multVectorMatrix(const VectorEntry&, const MatrixEntry&, VectorEntry&)#: vector * matrix

template<typename T, typename V, typename R> void xlifepp::multVectorMatrix(V *vp, const LargeMatrix<T> &mat, R *rp)#: templated vec<V> * mat<T> (pointer form)