Class xlifepp::Operand#

class Operand#

to deal with syntax Value AlgebraicOperation

Public Functions

Operand(const Function&, AlgebraicOperator)#: construct Operand from a Function (id on Function)

Operand(const Kernel&, AlgebraicOperator)#: construct Operand from a Kernel (id on Function)

Operand(const Operand&)#: copy construct

Operand(const OperatorOnFunction&, AlgebraicOperator)#: construct Operand from a OperatorOnFunction

Operand(const OperatorOnKernel&, AlgebraicOperator)#: construct Operand from a OperatorOnKernel

template<typename T> Operand(const T&, AlgebraicOperator)#: construct Operand from a scalar, a Vector or a Matrix

Operand(const Value&, AlgebraicOperator)#: construct Operand from a Value (Value is copied)

Operand(const Value*, AlgebraicOperator)#: construct Operand from a Value* (Value is not copied)

Operand(OperatorOnKernel&, AlgebraicOperator)#: construct Operand from a OperatorOnKernel

inline ~Operand()#: destructor

string_t asString() const#: return as symbolic string

inline void changeKernel(Kernel *ker)#: change Kernel in operator

void clear()#: delete allocated pointers and reset pointers to 0

void copy(const Operand&)#: copy tool

inline dimPair dims() const#: returns dimensions

bool elementRequired() const#: true if element is required by any function in

inline const Extension *extension() const#: return extension

const Function &function() const#: return operand object as function

inline const Function *functionp() const#: return pointer to function (0 if not)

inline bool hasExtension() const#: true if opfun or opker handle an extension

inline bool isFunction() const#: true if operand with function

inline bool isKernel() const#: true if operand with kernel

inline bool isValue() const#: true if operand with value

const Kernel &kernel() const#: return operand object as kernel

inline const Kernel *kernelp() const#: return pointer to kernel (0 if not)

template<typename T, typename R> inline Vector<T> leftEval(const Point&, const Point&, const Vector<R>&, dimen_t&, dimen_t&, number_t, const Vector<real_t>* = nullptr, const Vector<real_t>* = nullptr) const#

evaluate kernel operand at left

f(p) op V

template<typename T, typename R> inline Vector<T> leftEval(const Point&, const Vector<R>&, dimen_t&, dimen_t&, number_t, const Vector<real_t>* = nullptr, const ExtensionData* = nullptr) const#

evaluate function operand at left

f(p) op V

template<typename T, typename R> inline Vector<T> leftEval(const Vector<R>&, dimen_t&, dimen_t&, number_t) const#

evaluate value operand at left

evaluate operand with value or function at left or right applied to a collection of scalar/vector/matrix values of m basis functions (v_1)_1,…,(v_1)_d,(v_2)_1,…,(v_2)_d, …, (v_m)_1,…,(v_m)_d return in same structure w= op aop v (w_1)_1,…,(w_1)_q,(w_2)_1,…,(w_2)_q, …, (w_m)_1,…,(w_m)_q

v: basis function values m: number of blocks (each block corresponds to a basis function) d: size of block (may be updated) n: dimension of matrix, when blocks are matrices (p=d/n): [v_1,…,v_d] = [v_11,…,v_1n, v_21,…,v_2n, …, v_p1,…,v_pn]

Note: no consistency test are done here !!! Note: d and n may be updated by operations value op V

bool normalRequired() const#: true if normal involved

inline AlgebraicOperator operation() const#: returns algebraic operation

Operand &operator=(const Operand&)#: assign operator

const OperatorOnFunction &opfunction() const#: return operand object as operator on function

inline const OperatorOnFunction *opfunctionp() const#: return operand object as pointer to operator on function

const OperatorOnKernel &opkernel() const#: return operand object as operator on kernel

inline const OperatorOnKernel *opkernelp() const#: return operand object as pointer to operator on kernel

inline void print(PrintStream &os) const#: print Operand attributes

void print(std::ostream&) const#: print Operand attributes

inline void printsymbolic(PrintStream &os) const#: print Operand in symbolic form

void printsymbolic(std::ostream&) const#: print Operand in symbolic form

template<typename T, typename R> inline Vector<T> rightEval(const Point&, const Point&, const Vector<R>&, dimen_t&, dimen_t&, number_t, const Vector<real_t>* = nullptr, const Vector<real_t>* = nullptr) const#

evaluate kernel operand at right

V op f(p)

template<typename T, typename R> inline Vector<T> rightEval(const Point&, const Vector<R>&, dimen_t&, dimen_t&, number_t, const Vector<real_t>* = nullptr, const ExtensionData* = nullptr) const#

evaluate function operand at right

V op f(p)

template<typename T, typename R> inline Vector<T> rightEval(const Vector<R>&, dimen_t&, dimen_t&, number_t) const#

evaluate value operand at right

V op value.

inline void setX(const Point &P) const#: set X point if Function involved (usefull for Kernel)

inline void setY(const Point &P) const#: set Y point if Function involved (usefull for Kernel)

StrucType strucType() const#: return structure type of value or function

bool tangentRequired() const#: true if tangent involved

Value &value()#: return the operand value as object

const Value &value() const#: return the operand value as object

template<class T> inline T &value(T&) const#: return const value

template<class T> inline T &value(T&, const Point&, const Point&, const Vector<real_t> *nxp = nullptr, const Vector<real_t> *nyp = nullptr) const#: compute value kernel

template<class T> inline T &value(T&, const Point&, const Vector<real_t> *np = nullptr, const ExtensionData* = nullptr) const#: compute value function

template<class T> inline T &valueT() const#: return operand object as value of T type

ValueType valueType() const#: return value type of value or function

bool xnormalRequired() const#: true if xnormal involved

bool xtangentRequired() const#: true if xtangent involved

bool ynormalRequired() const#: true if ynormal involved

bool ytangentRequired() const#: true if ytangent involved

Public Members

mutable bool conjugate_#: true if the operand has to be conjugated

mutable bool transpose_#: true if the operand has to be transposed