xlifepp – Functions – U#

umfpackFactorize#

template<typename S>
void xlifepp::umfpackFactorize(LargeMatrix<S> &mat)#
void xlifepp::umfpackFactorize(TermMatrix &A, TermMatrix &Af)#

umfpackSolve#

void xlifepp::umfpackSolve(MatrixEntry&, std::vector<VectorEntry*>&, std::vector<VectorEntry*>&, real_t&)#

umfpack solver with multiple right hand side (only in scalar representation)

void xlifepp::umfpackSolve(MatrixEntry&, VectorEntry&, VectorEntry&, real_t&)#

umfpack solver (only in scalar representation)

SuTermVector xlifepp::umfpackSolve(SuTermMatrix&, const SuTermVector&, bool keepA = false)#

solve AX=B using umfpack if available

SuTermVector xlifepp::umfpackSolve(SuTermMatrix &A, const SuTermVector &B, real_t &rcond, bool keepA)#
TermVectors xlifepp::umfpackSolve(TermMatrix &A, const std::vector<TermVector> &Bs, bool keepA)#
TermVectors xlifepp::umfpackSolve(TermMatrix &A, const std::vector<TermVector> &Bs, real_t &rcond, bool keepA)#
TermVector xlifepp::umfpackSolve(TermMatrix &A, const TermVector &B, bool keepA)#
TermVector xlifepp::umfpackSolve(TermMatrix &A, const TermVector &B, real_t &rcond, bool keepA)#

unCurvatures#

inline Vector<real_t> xlifepp::unCurvatures(const Point &p, bool fromParameters, Parameters &pars)#

uniformDistribution#

void xlifepp::uniformDistribution(complex_t *mat, number_t n = 1, number_t m = 1)#

compute a matrix with complex coefficient following an uniform distribution on [0,1[ (using <random> if C11)

void xlifepp::uniformDistribution(complex_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)#

compute a matrix with complex coefficient following an uniform distribution on [a,b[ (using <random> if C11)

template<typename T>
std::vector<T> xlifepp::uniformDistribution(number_t n, number_t m, real_t a = 0., real_t b = 1.)#
template<typename T>
std::vector<T> xlifepp::uniformDistribution(number_t n, real_t a = 0., real_t b = 1.)#
void xlifepp::uniformDistribution(real_t *mat, number_t n = 1, number_t m = 1)#

compute a matrix with real coefficient following an uniform distribution on [0,1[ (using <random> if C11)

void xlifepp::uniformDistribution(real_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)#

compute a matrix with real coefficient following an uniform distribution on [a,b[ (using <random> if C11)

real_t xlifepp::uniformDistribution(real_t a = 0., real_t b = 1.)#

return a sample from an uniform distribution on [a,b[ (using <random> if C11)

template<typename T>
void xlifepp::uniformDistribution(std::vector<T> &mat, number_t n, number_t m, real_t a = 0., real_t b = 1.)#
template<typename T>
void xlifepp::uniformDistribution(std::vector<T> &v, real_t a = 0., real_t b = 1.)#

uniformDistributionC#

void xlifepp::uniformDistributionC(complex_t *mat, number_t n = 1, number_t m = 1)#

compute a matrix with complex coefficient following an uniform distribution on [0,1[ (using rand())

void xlifepp::uniformDistributionC(complex_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)#

compute a matrix with complex coefficient following an uniform distribution on [a,b[ (using rand())

void xlifepp::uniformDistributionC(real_t *mat, number_t n = 1, number_t m = 1)#

compute a matrix with real coefficient following an uniform distribution on [0,1[ (using rand())

void xlifepp::uniformDistributionC(real_t *mat, real_t a, real_t b, number_t n = 1, number_t m = 1)#

compute a matrix with real coefficient following an uniform distribution on [a,b[ (using rand())

real_t xlifepp::uniformDistributionC(real_t a = 0., real_t b = 1.)#

return a sample from an uniform distribution on [a,b[ (using rand())

unionOf#

Space *xlifepp::unionOf(std::vector<Space*> &sps)#

union of subspaces the result, returned as space pointer, may be

union of subspaces

  • one subspace of the list if it includes all others

  • the root space if the union gives the whole space

  • a new subspace

unknownEcName#

string_t xlifepp::unknownEcName(const EssentialCondition&)#

to create an unknown name associated to an essential condition

updateAcaPlus#

template<typename ITV, typename ITAB, typename T>
void xlifepp::updateAcaPlus(ITV itv, ITAB itAb, ITAB itBb, number_t mn, number_t lmax, number_t ijp, bool row, T &piv, number_t &jip, bool updatePiv, std::vector<number_t> *rowcol = nullptr)#

updateLeft#

OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown&, const Function&, AlgebraicOperator)#

update F*Op(u) operation

OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown&, const OperatorOnFunction&, AlgebraicOperator)#

update op(F)*Op(u) operation

OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown&, const Value&, AlgebraicOperator)#

update V*Op(u) operation

template<typename T>
OperatorOnUnknown &xlifepp::updateLeft(OperatorOnUnknown &opu, const T &val, AlgebraicOperator o)#

updateRhs#

void xlifepp::updateRhs(TermMatrix&, TermVector&)#

prepare rhs B of linear system AX=B (internal tool)

updateRight#

OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown&, const Function&, AlgebraicOperator)#

update Op(u)*F operation

OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown&, const OperatorOnFunction&, AlgebraicOperator)#

update Op(u)*op(F) operation

OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown&, const Value&, AlgebraicOperator)#

update Op(u)*V operation

template<typename T>
OperatorOnUnknown &xlifepp::updateRight(OperatorOnUnknown &opu, const T &val, AlgebraicOperator o)#

updateStorage#

MatrixStorage *xlifepp::updateStorage(MatrixStorage &stm, const std::vector<number_t> rows, const std::vector<number_t> cols, StorageType st, AccessType at, bool overwrite)#

modify MatrixStorage stm to include dense submatrix given by its row and column indices (rows and cols) the new storage is of type (st,at) rows (resp.

update storage for adding dense submatrix given by its row and column indices

cols) has to be a subset of row indices (resp. column indices) of the stm storage if overwrite=true the current storage is overwritten and returned else a new MatrixStorage is returned, the stm storage being not cleared!

uppercase#

string_t xlifepp::uppercase(const string_t &s)#

convert “AbCdefg” to “ABCDEFG”

returns string_t converted to uppercase

upperDegreeRule#

void xlifepp::upperDegreeRule(int degree, const string_t &name, ShapeType sh)#

warning message

userBilinearForm#

BilinearForm xlifepp::userBilinearForm(const GeomDomain &dom, const Unknown &u, const Unknown &v, BFFunction bffun, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)#
BilinearForm xlifepp::userBilinearForm(const GeomDomain &dom, const Unknown &u, const Unknown &v, BFFunctionP bffun, const Parameters &pa, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)#
BilinearForm xlifepp::userBilinearForm(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Unknown &v, BFFunction bffun, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)#
BilinearForm xlifepp::userBilinearForm(const GeomDomain &domv, const GeomDomain &domu, const Unknown &u, const Unknown &v, BFFunctionP bffun, const Parameters &pa, ComputationType ct, SymType st, bool reqIJ, bool reqN, const IntegrationMethod &im)#

print utility

interpret as string for print purpose