Class xlifepp::Operand

class Operand

Collaboration diagram for xlifepp::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