CAPD::DynSys Library  6.0.0
Files | Classes | Macros | Typedefs | Enumerations | Functions | Variables
Autodiff

Files

file  Parser.cpp
 
file  Parser.cpp
 

Classes

class  capd::autodiff::AcosNode< T >
 
class  capd::autodiff::AcosConstNode< T >
 
class  capd::autodiff::AcosTimeNode< T >
 
class  capd::autodiff::AcosFunTimeNode< T >
 
class  capd::autodiff::AddNode< T >
 
class  capd::autodiff::ConstPlusVarNode< T >
 
class  capd::autodiff::ConstPlusConstNode< T >
 
class  capd::autodiff::ConstPlusTimeNode< T >
 
class  capd::autodiff::ConstPlusFunTimeNode< T >
 
class  capd::autodiff::TimePlusVarNode< T >
 
class  capd::autodiff::TimePlusFunTimeNode< T >
 
class  capd::autodiff::FunTimePlusVarNode< T >
 
class  capd::autodiff::FunTimePlusFunTimeNode< T >
 
class  capd::autodiff::AsinNode< T >
 
class  capd::autodiff::AsinConstNode< T >
 
class  capd::autodiff::AsinTimeNode< T >
 
class  capd::autodiff::AsinFunTimeNode< T >
 
class  capd::autodiff::AtanNode< T >
 
class  capd::autodiff::AtanConstNode< T >
 
class  capd::autodiff::AtanTimeNode< T >
 
class  capd::autodiff::AtanFunTimeNode< T >
 
class  capd::autodiff::DivNode< T >
 
class  capd::autodiff::DivVarByConstNode< T >
 
class  capd::autodiff::DivVarByTimeNode< T >
 
class  capd::autodiff::DivVarByFunTimeNode< T >
 
class  capd::autodiff::DivTimeByConstNode< T >
 
class  capd::autodiff::DivFunTimeByConstNode< T >
 
class  capd::autodiff::DivFunTimeByTimeNode< T >
 
class  capd::autodiff::DivFunTimeByFunTimeNode< T >
 
class  capd::autodiff::DivConstByConstNode< T >
 
class  capd::autodiff::ExpNode< T >
 
class  capd::autodiff::ExpConstNode< T >
 
class  capd::autodiff::ExpTimeNode< T >
 
class  capd::autodiff::ExpFunTimeNode< T >
 
class  capd::autodiff::HalfIntPowNode< T >
 
class  capd::autodiff::HalfIntPowConstNode< T >
 
class  capd::autodiff::HalfIntPowTimeNode< T >
 
class  capd::autodiff::HalfIntPowFunTimeNode< T >
 
class  capd::autodiff::LogNode< T >
 
class  capd::autodiff::LogConstNode< T >
 
class  capd::autodiff::LogTimeNode< T >
 
class  capd::autodiff::LogFunTimeNode< T >
 
class  capd::autodiff::MulNode< T >
 
class  capd::autodiff::MulConstByVarNode< T >
 
class  capd::autodiff::MulConstByConstNode< T >
 
class  capd::autodiff::MulConstByTimeNode< T >
 
class  capd::autodiff::MulConstByFunTimeNode< T >
 
class  capd::autodiff::MulTimeByVarNode< T >
 
class  capd::autodiff::MulTimeByFunTimeNode< T >
 
class  capd::autodiff::MulFunTimeByVarNode< T >
 
class  capd::autodiff::MulFunTimeByFunTimeNode< T >
 
class  capd::autodiff::NaturalPowConstNode< T >
 
class  capd::autodiff::NaturalPowTimeNode< T >
 
class  capd::autodiff::NaturalPowNode< T >
 
class  capd::autodiff::NaturalPowFunTimeNode< T >
 
class  capd::autodiff::NegIntPowNode< T >
 
class  capd::autodiff::NegIntPowConstNode< T >
 
class  capd::autodiff::NegIntPowTimeNode< T >
 
class  capd::autodiff::NegIntPowFunTimeNode< T >
 
class  capd::autodiff::OneMinusSqrNode< T >
 
class  capd::autodiff::OneMinusSqrTimeNode< T >
 
class  capd::autodiff::OneMinusSqrFunTimeNode< T >
 
class  capd::autodiff::OneMinusSqrConstNode< T >
 
class  capd::autodiff::PowNode< T >
 
class  capd::autodiff::PowConstNode< T >
 
class  capd::autodiff::PowTimeNode< T >
 
class  capd::autodiff::PowFunTimeNode< T >
 
class  capd::autodiff::QuarticNode< T >
 
class  capd::autodiff::QuarticTimeNode< T >
 
class  capd::autodiff::QuarticFunTimeNode< T >
 
class  capd::autodiff::QuarticConstNode< T >
 
class  capd::autodiff::SinNode< T >
 
class  capd::autodiff::SinConstNode< T >
 
class  capd::autodiff::SinTimeNode< T >
 
class  capd::autodiff::SinFunTimeNode< T >
 
class  capd::autodiff::SqrNode< T >
 
class  capd::autodiff::SqrTimeNode< T >
 
class  capd::autodiff::SqrFunTimeNode< T >
 
class  capd::autodiff::SqrConstNode< T >
 
class  capd::autodiff::SqrtNode< T >
 
class  capd::autodiff::SqrtConstNode< T >
 
class  capd::autodiff::SqrtTimeNode< T >
 
class  capd::autodiff::SqrtFunTimeNode< T >
 
class  capd::autodiff::SubNode< T >
 
class  capd::autodiff::ConstMinusVarNode< T >
 
class  capd::autodiff::ConstMinusFunTimeNode< T >
 
class  capd::autodiff::ConstMinusTimeNode< T >
 
class  capd::autodiff::ConstMinusConstNode< T >
 
class  capd::autodiff::TimeMinusConstNode< T >
 
class  capd::autodiff::TimeMinusFunTimeNode< T >
 
class  capd::autodiff::TimeMinusVarNode< T >
 
class  capd::autodiff::FunTimeMinusConstNode< T >
 
class  capd::autodiff::FunTimeMinusTimeNode< T >
 
class  capd::autodiff::FunTimeMinusFunTimeNode< T >
 
class  capd::autodiff::FunTimeMinusVarNode< T >
 
class  capd::autodiff::VarMinusConstNode< T >
 
class  capd::autodiff::VarMinusTimeNode< T >
 
class  capd::autodiff::VarMinusFunTimeNode< T >
 
class  capd::autodiff::CubeNode< T >
 
class  capd::autodiff::CubeTimeNode< T >
 
class  capd::autodiff::CubeFunTimeNode< T >
 
class  capd::autodiff::CubeConstNode< T >
 
class  capd::autodiff::UnaryMinusNode< T >
 
class  capd::autodiff::UnaryMinusConstNode< T >
 
class  capd::autodiff::UnaryMinusTimeNode< T >
 
class  capd::autodiff::UnaryMinusFunTimeNode< T >
 
struct  capd::autodiff::MaskIterator< T >
 
struct  capd::autodiff::Int4
 
struct  capd::autodiff::Node
 
class  capd::autodiff::AbstractNode< T >
 

Macros

#define CAPD_MAKE_NAT_POW_NODE(ClassName)
 
#define CAPD_MAKE_DAG_NODE(ClassName)
 

Typedefs

typedef Int4 capd::autodiff::MyNode
 

Enumerations

enum  capd::autodiff::NodeType {
  capd::autodiff::NODE_ADD =0 , capd::autodiff::NODE_CONST_PLUS_VAR =1 , capd::autodiff::NODE_CONST_PLUS_CONST =2 , capd::autodiff::NODE_CONST_PLUS_TIME =3 ,
  capd::autodiff::NODE_CONST_PLUS_FUNTIME =4 , capd::autodiff::NODE_TIME_PLUS_VAR =5 , capd::autodiff::NODE_TIME_PLUS_FUNTIME =6 , capd::autodiff::NODE_FUNTIME_PLUS_VAR =7 ,
  capd::autodiff::NODE_FUNTIME_PLUS_FUNTIME =8 , capd::autodiff::NODE_SUB =10 , capd::autodiff::NODE_CONST_MINUS_CONST =11 , capd::autodiff::NODE_CONST_MINUS_VAR =12 ,
  capd::autodiff::NODE_CONST_MINUS_TIME =13 , capd::autodiff::NODE_CONST_MINUS_FUNTIME =14 , capd::autodiff::NODE_TIME_MINUS_CONST =15 , capd::autodiff::NODE_TIME_MINUS_FUNTIME =16 ,
  capd::autodiff::NODE_TIME_MINUS_VAR =17 , capd::autodiff::NODE_FUNTIME_MINUS_CONST =18 , capd::autodiff::NODE_FUNTIME_MINUS_TIME =19 , capd::autodiff::NODE_FUNTIME_MINUS_FUNTIME =20 ,
  capd::autodiff::NODE_FUNTIME_MINUS_VAR =21 , capd::autodiff::NODE_VAR_MINUS_CONST =22 , capd::autodiff::NODE_VAR_MINUS_TIME =23 , capd::autodiff::NODE_VAR_MINUS_FUNTIME =24 ,
  capd::autodiff::NODE_UNARY_MINUS =30 , capd::autodiff::NODE_UNARY_MINUS_CONST =31 , capd::autodiff::NODE_UNARY_MINUS_TIME =32 , capd::autodiff::NODE_UNARY_MINUS_FUNTIME =33 ,
  capd::autodiff::NODE_MUL =40 , capd::autodiff::NODE_MUL_CONST_BY_VAR =41 , capd::autodiff::NODE_MUL_CONST_BY_CONST =42 , capd::autodiff::NODE_MUL_CONST_BY_TIME =43 ,
  capd::autodiff::NODE_MUL_CONST_BY_FUNTIME =44 , capd::autodiff::NODE_MUL_TIME_BY_VAR =45 , capd::autodiff::NODE_MUL_TIME_BY_FUNTIME =46 , capd::autodiff::NODE_MUL_FUNTIME_BY_VAR =47 ,
  capd::autodiff::NODE_MUL_FUNTIME_BY_FUNTIME =48 , capd::autodiff::NODE_DIV =50 , capd::autodiff::NODE_DIV_VAR_BY_CONST =51 , capd::autodiff::NODE_DIV_VAR_BY_TIME =52 ,
  capd::autodiff::NODE_DIV_VAR_BY_FUNTIME =53 , capd::autodiff::NODE_DIV_TIME_BY_CONST =54 , capd::autodiff::NODE_DIV_FUNTIME_BY_CONST =55 , capd::autodiff::NODE_DIV_FUNTIME_BY_TIME =56 ,
  capd::autodiff::NODE_DIV_FUNTIME_BY_FUNTIME =57 , capd::autodiff::NODE_DIV_CONST_BY_CONST =58 , capd::autodiff::NODE_SQR =60 , capd::autodiff::NODE_SQR_CONST =61 ,
  capd::autodiff::NODE_SQR_TIME =62 , capd::autodiff::NODE_SQR_FUNTIME =63 , capd::autodiff::NODE_SQRT =64 , capd::autodiff::NODE_SQRT_CONST =65 ,
  capd::autodiff::NODE_SQRT_TIME =66 , capd::autodiff::NODE_SQRT_FUNTIME =67 , capd::autodiff::NODE_POW =70 , capd::autodiff::NODE_POW_CONST =71 ,
  capd::autodiff::NODE_POW_TIME =72 , capd::autodiff::NODE_POW_FUNTIME =73 , capd::autodiff::NODE_NATURAL_POW =74 , capd::autodiff::NODE_NATURAL_POW_CONST =75 ,
  capd::autodiff::NODE_NATURAL_POW_TIME =76 , capd::autodiff::NODE_NATURAL_POW_FUNTIME =77 , capd::autodiff::NODE_NEG_INT_POW =78 , capd::autodiff::NODE_NEG_INT_POW_CONST =79 ,
  capd::autodiff::NODE_NEG_INT_POW_TIME =80 , capd::autodiff::NODE_NEG_INT_POW_FUNTIME =81 , capd::autodiff::NODE_HALF_INT_POW =82 , capd::autodiff::NODE_HALF_INT_POW_CONST =83 ,
  capd::autodiff::NODE_HALF_INT_POW_TIME =84 , capd::autodiff::NODE_HALF_INT_POW_FUNTIME =85 , capd::autodiff::NODE_CUBE =86 , capd::autodiff::NODE_CUBE_CONST =87 ,
  capd::autodiff::NODE_CUBE_TIME =88 , capd::autodiff::NODE_CUBE_FUNTIME =89 , capd::autodiff::NODE_QUARTIC =90 , capd::autodiff::NODE_QUARTIC_CONST =91 ,
  capd::autodiff::NODE_QUARTIC_TIME =92 , capd::autodiff::NODE_QUARTIC_FUNTIME =93 , capd::autodiff::NODE_EXP =100 , capd::autodiff::NODE_EXP_CONST =101 ,
  capd::autodiff::NODE_EXP_TIME =102 , capd::autodiff::NODE_EXP_FUNTIME =103 , capd::autodiff::NODE_LOG =104 , capd::autodiff::NODE_LOG_CONST =105 ,
  capd::autodiff::NODE_LOG_TIME =106 , capd::autodiff::NODE_LOG_FUNTIME =107 , capd::autodiff::NODE_SIN =110 , capd::autodiff::NODE_SIN_CONST =111 ,
  capd::autodiff::NODE_SIN_TIME =112 , capd::autodiff::NODE_SIN_FUNTIME =113 , capd::autodiff::NODE_ATAN , capd::autodiff::NODE_ATAN_CONST ,
  capd::autodiff::NODE_ATAN_TIME , capd::autodiff::NODE_ATAN_FUNTIME , capd::autodiff::NODE_ONE_MINUS_SQR , capd::autodiff::NODE_ONE_MINUS_SQR_CONST ,
  capd::autodiff::NODE_ONE_MINUS_SQR_TIME , capd::autodiff::NODE_ONE_MINUS_SQR_FUNTIME , capd::autodiff::NODE_ASIN , capd::autodiff::NODE_ASIN_CONST ,
  capd::autodiff::NODE_ASIN_TIME , capd::autodiff::NODE_ASIN_FUNTIME , capd::autodiff::NODE_ACOS , capd::autodiff::NODE_ACOS_CONST ,
  capd::autodiff::NODE_ACOS_TIME , capd::autodiff::NODE_ACOS_FUNTIME , capd::autodiff::NODE_NULL , capd::autodiff::NODE_CONST ,
  capd::autodiff::NODE_TIME , capd::autodiff::NODE_PARAM , capd::autodiff::NODE_VAR , capd::autodiff::NODE_COS
}
 

Functions

template<class T >
void capd::autodiff::Int4ToAbstractNode (const std::vector< MyNode > &node, std::vector< AbstractNode< T > * > &out, capd::autodiff::DagIndexer< T > &dag)
 
template<class T >
bool capd::autodiff::getMask (MaskIterator< T > i)
 
template<class T >
bool capd::autodiff::getMask (MaskIterator< T > i, unsigned j)
 
template<class T >
bool capd::autodiff::getMask (T *)
 
template<class T >
bool capd::autodiff::getMask (T *, unsigned)
 
Node capd::autodiff::operator+ (const Node &x, const Node &y)
 
Node capd::autodiff::operator+ (const Node &x, double y)
 
Node capd::autodiff::operator+ (double x, const Node &y)
 
Node capd::autodiff::operator- (const Node &x, const Node &y)
 
Node capd::autodiff::operator- (const Node &x, double y)
 
Node capd::autodiff::operator- (double x, const Node &y)
 
Node capd::autodiff::operator- (const Node &x)
 
Node capd::autodiff::operator* (const Node &x, const Node &y)
 
Node capd::autodiff::operator* (const Node &x, double y)
 
Node capd::autodiff::operator* (double x, const Node &y)
 
Node capd::autodiff::operator/ (const Node &x, const Node &y)
 
Node capd::autodiff::operator/ (const Node &x, double y)
 
Node capd::autodiff::operator/ (double x, const Node &y)
 
Node capd::autodiff::operator^ (const Node &x, double)
 
Node & capd::autodiff::operator+= (Node &x, const Node &y)
 
Node & capd::autodiff::operator+= (Node &x, double y)
 
Node & capd::autodiff::operator-= (Node &x, const Node &y)
 
Node & capd::autodiff::operator-= (Node &x, double y)
 
Node & capd::autodiff::operator*= (Node &x, const Node &y)
 
Node & capd::autodiff::operator*= (Node &x, double y)
 
Node & capd::autodiff::operator/= (Node &x, const Node &y)
 
Node & capd::autodiff::operator/= (Node &x, double y)
 
capd::autodiff::Node createBinaryNode (const capd::autodiff::Node &left, const capd::autodiff::Node &right, capd::autodiff::NodeType op)
 a general function for creating new binary node in DAG representing an expression should not been used by a user More...
 
capd::autodiff::Node createUnaryNode (const capd::autodiff::Node &left, capd::autodiff::NodeType op)
 a general function for creating new unary node in DAG representing an expression should not been used by a user More...
 
capd::autodiff::Node sqr (const capd::autodiff::Node &x)
 
capd::autodiff::Node sqrt (const capd::autodiff::Node &x)
 
capd::autodiff::Node exp (const capd::autodiff::Node &x)
 
capd::autodiff::Node log (const capd::autodiff::Node &x)
 
capd::autodiff::Node sin (const capd::autodiff::Node &x)
 
capd::autodiff::Node cos (const capd::autodiff::Node &x)
 
capd::autodiff::Node atan (const capd::autodiff::Node &x)
 
capd::autodiff::Node asin (const capd::autodiff::Node &x)
 
capd::autodiff::Node acos (const capd::autodiff::Node &x)
 

Variables

static std::vector< Node > * capd::autodiff::Node::dag = 0
 

Detailed Description

Macro Definition Documentation

◆ CAPD_MAKE_DAG_NODE

#define CAPD_MAKE_DAG_NODE (   ClassName)
Value:
template<class T>\
class ClassName##Node : public AbstractNode<T>\
{ \
public:\
void evalC0(const int coeffNo) {\
ClassName::evalC0(this->left,this->right,this->result,coeffNo);\
}\
void eval(const int degree, const int coeffNo) {\
ClassName::eval(degree,this->left,this->right,this->result,this->dag,coeffNo);\
}\
void eval(const int degree, const int coeffNo, const bool* mask) {\
ClassName::eval(degree,this->left,this->right,MaskIterator<T>(this->result,mask),this->dag,coeffNo);\
}\
void evalC0HomogenousPolynomial() {\
ClassName::evalC0HomogenousPolynomial(this->left,this->right,this->result);\
}\
void evalHomogenousPolynomial(const int degree, const int coeffNo) {\
ClassName::evalHomogenousPolynomial(degree,this->left,this->right,this->result,this->dag,coeffNo);\
}\
void evalHomogenousPolynomial(const int degree, const int coeffNo, const bool* mask) {\
ClassName::evalHomogenousPolynomial(degree,this->left,this->right,MaskIterator<T>(this->result,mask),this->dag,coeffNo);\
}\
const char* name() const {\
return #ClassName;\
}\
}
right
long double right(long double x)
Definition: doubleFun.h:95
left
long double left(long double x)
Definition: doubleFun.h:85
capd::autodiff::Acos::evalC0HomogenousPolynomial
void evalC0HomogenousPolynomial(const T *left, const T *, R result)
Definition: EvalAcos.h:42
capd::autodiff::Acos::evalC0
void evalC0(const T *left, const T *right, R result, const unsigned coeffNo)
Definition: EvalAcos.h:28
capd::autodiff::Acos::evalHomogenousPolynomial
void evalHomogenousPolynomial(const unsigned degree, const T *left, const T *right, R result, DagIndexer< T > *dag, const unsigned coeffNo)
Definition: EvalAcos.h:102
capd::autodiff::Acos::eval
void eval(const unsigned degree, const T *left, const T *right, R result, DagIndexer< T > *dag, const unsigned coeffNo)
Definition: EvalAcos.h:82

◆ CAPD_MAKE_NAT_POW_NODE

#define CAPD_MAKE_NAT_POW_NODE (   ClassName)
Value:
template<class T>\
class ClassName##Node : public AbstractNode<T>\
{ \
public:\
void evalC0(const int coeffNo) {\
ClassName::evalC0(this->left,this->right,this->result,this->dag,coeffNo);\
}\
void eval(const int degree, const int coeffNo) {\
ClassName::eval(degree,this->left,this->right,this->result,this->dag,coeffNo);\
}\
void eval(const int degree, const int coeffNo, const bool* mask) {\
ClassName::eval(degree,this->left,this->right,MaskIterator<T>(this->result,mask),this->dag,coeffNo);\
}\
void evalC0HomogenousPolynomial() {\
ClassName::evalC0HomogenousPolynomial(this->left,this->right,this->result,this->dag);\
}\
void evalHomogenousPolynomial(const int degree, const int coeffNo) {\
ClassName::evalHomogenousPolynomial(degree,this->left,this->right,this->result,this->dag,coeffNo);\
}\
void evalHomogenousPolynomial(const int degree, const int coeffNo, const bool* mask) {\
ClassName::evalHomogenousPolynomial(degree,this->left,this->right,MaskIterator<T>(this->result,mask),this->dag,coeffNo);\
}\
const char* name() const {\
return #ClassName;\
}\
}
capd::autodiff::NaturalPowConst::evalC0HomogenousPolynomial
void evalC0HomogenousPolynomial(const T *left, const T *right, R result)
Definition: EvalNaturalPow.h:306
capd::autodiff::NaturalPowConst::eval
void eval(const unsigned, const T *left, const T *right, R result, DagIndexer< T > *, const unsigned coeffNo)
Definition: EvalNaturalPow.h:312
capd::autodiff::NaturalPowConst::evalC0
void evalC0(const T *left, const T *right, R result, const unsigned coeffNo)
Definition: EvalNaturalPow.h:299
capd::autodiff::NaturalPowConst::evalHomogenousPolynomial
void evalHomogenousPolynomial(const unsigned, const T *, const T *, R, DagIndexer< T > *, const unsigned)
Definition: EvalNaturalPow.h:319

Typedef Documentation

◆ MyNode

typedef Int4 capd::autodiff::MyNode

Enumeration Type Documentation

◆ NodeType

enum capd::autodiff::NodeType
Enumerator
NODE_ADD 
NODE_CONST_PLUS_VAR 
NODE_CONST_PLUS_CONST 
NODE_CONST_PLUS_TIME 
NODE_CONST_PLUS_FUNTIME 
NODE_TIME_PLUS_VAR 
NODE_TIME_PLUS_FUNTIME 
NODE_FUNTIME_PLUS_VAR 
NODE_FUNTIME_PLUS_FUNTIME 
NODE_SUB 
NODE_CONST_MINUS_CONST 
NODE_CONST_MINUS_VAR 
NODE_CONST_MINUS_TIME 
NODE_CONST_MINUS_FUNTIME 
NODE_TIME_MINUS_CONST 
NODE_TIME_MINUS_FUNTIME 
NODE_TIME_MINUS_VAR 
NODE_FUNTIME_MINUS_CONST 
NODE_FUNTIME_MINUS_TIME 
NODE_FUNTIME_MINUS_FUNTIME 
NODE_FUNTIME_MINUS_VAR 
NODE_VAR_MINUS_CONST 
NODE_VAR_MINUS_TIME 
NODE_VAR_MINUS_FUNTIME 
NODE_UNARY_MINUS 
NODE_UNARY_MINUS_CONST 
NODE_UNARY_MINUS_TIME 
NODE_UNARY_MINUS_FUNTIME 
NODE_MUL 
NODE_MUL_CONST_BY_VAR 
NODE_MUL_CONST_BY_CONST 
NODE_MUL_CONST_BY_TIME 
NODE_MUL_CONST_BY_FUNTIME 
NODE_MUL_TIME_BY_VAR 
NODE_MUL_TIME_BY_FUNTIME 
NODE_MUL_FUNTIME_BY_VAR 
NODE_MUL_FUNTIME_BY_FUNTIME 
NODE_DIV 
NODE_DIV_VAR_BY_CONST 
NODE_DIV_VAR_BY_TIME 
NODE_DIV_VAR_BY_FUNTIME 
NODE_DIV_TIME_BY_CONST 
NODE_DIV_FUNTIME_BY_CONST 
NODE_DIV_FUNTIME_BY_TIME 
NODE_DIV_FUNTIME_BY_FUNTIME 
NODE_DIV_CONST_BY_CONST 
NODE_SQR 
NODE_SQR_CONST 
NODE_SQR_TIME 
NODE_SQR_FUNTIME 
NODE_SQRT 
NODE_SQRT_CONST 
NODE_SQRT_TIME 
NODE_SQRT_FUNTIME 
NODE_POW 
NODE_POW_CONST 
NODE_POW_TIME 
NODE_POW_FUNTIME 
NODE_NATURAL_POW 
NODE_NATURAL_POW_CONST 
NODE_NATURAL_POW_TIME 
NODE_NATURAL_POW_FUNTIME 
NODE_NEG_INT_POW 
NODE_NEG_INT_POW_CONST 
NODE_NEG_INT_POW_TIME 
NODE_NEG_INT_POW_FUNTIME 
NODE_HALF_INT_POW 
NODE_HALF_INT_POW_CONST 
NODE_HALF_INT_POW_TIME 
NODE_HALF_INT_POW_FUNTIME 
NODE_CUBE 
NODE_CUBE_CONST 
NODE_CUBE_TIME 
NODE_CUBE_FUNTIME 
NODE_QUARTIC 
NODE_QUARTIC_CONST 
NODE_QUARTIC_TIME 
NODE_QUARTIC_FUNTIME 
NODE_EXP 
NODE_EXP_CONST 
NODE_EXP_TIME 
NODE_EXP_FUNTIME 
NODE_LOG 
NODE_LOG_CONST 
NODE_LOG_TIME 
NODE_LOG_FUNTIME 
NODE_SIN 
NODE_SIN_CONST 
NODE_SIN_TIME 
NODE_SIN_FUNTIME 
NODE_ATAN 
NODE_ATAN_CONST 
NODE_ATAN_TIME 
NODE_ATAN_FUNTIME 
NODE_ONE_MINUS_SQR 
NODE_ONE_MINUS_SQR_CONST 
NODE_ONE_MINUS_SQR_TIME 
NODE_ONE_MINUS_SQR_FUNTIME 
NODE_ASIN 
NODE_ASIN_CONST 
NODE_ASIN_TIME 
NODE_ASIN_FUNTIME 
NODE_ACOS 
NODE_ACOS_CONST 
NODE_ACOS_TIME 
NODE_ACOS_FUNTIME 
NODE_NULL 
NODE_CONST 
NODE_TIME 
NODE_PARAM 
NODE_VAR 
NODE_COS 

Function Documentation

◆ acos()

capd::autodiff::Node acos ( const capd::autodiff::Node &  x)

◆ asin()

capd::autodiff::Node asin ( const capd::autodiff::Node &  x)

◆ atan()

capd::autodiff::Node atan ( const capd::autodiff::Node &  x)

◆ cos()

capd::autodiff::Node cos ( const capd::autodiff::Node &  x)

◆ createBinaryNode()

capd::autodiff::Node createBinaryNode ( const capd::autodiff::Node &  left,
const capd::autodiff::Node &  right,
capd::autodiff::NodeType  op 
)

a general function for creating new binary node in DAG representing an expression should not been used by a user

◆ createUnaryNode()

capd::autodiff::Node createUnaryNode ( const capd::autodiff::Node &  left,
capd::autodiff::NodeType  op 
)

a general function for creating new unary node in DAG representing an expression should not been used by a user

◆ exp()

capd::autodiff::Node exp ( const capd::autodiff::Node &  x)

◆ getMask() [1/4]

template<class T >
bool capd::autodiff::getMask ( MaskIterator< T >  i)
inline

◆ getMask() [2/4]

template<class T >
bool capd::autodiff::getMask ( MaskIterator< T >  i,
unsigned  j 
)
inline

◆ getMask() [3/4]

template<class T >
bool capd::autodiff::getMask ( T *  )
inline

◆ getMask() [4/4]

template<class T >
bool capd::autodiff::getMask ( T *  ,
unsigned   
)
inline

◆ Int4ToAbstractNode()

template<class T >
void capd::autodiff::Int4ToAbstractNode ( const std::vector< MyNode > &  node,
std::vector< AbstractNode< T > * > &  out,
capd::autodiff::DagIndexer< T > &  dag 
)

◆ log()

capd::autodiff::Node log ( const capd::autodiff::Node &  x)

◆ operator*() [1/3]

Node capd::autodiff::operator* ( const Node &  x,
const Node &  y 
)

◆ operator*() [2/3]

Node capd::autodiff::operator* ( const Node &  x,
double  y 
)

◆ operator*() [3/3]

Node capd::autodiff::operator* ( double  x,
const Node &  y 
)

◆ operator*=() [1/2]

Node & capd::autodiff::operator*= ( Node &  x,
const Node &  y 
)

◆ operator*=() [2/2]

Node & capd::autodiff::operator*= ( Node &  x,
double  y 
)

◆ operator+() [1/3]

Node capd::autodiff::operator+ ( const Node &  x,
const Node &  y 
)

◆ operator+() [2/3]

Node capd::autodiff::operator+ ( const Node &  x,
double  y 
)

◆ operator+() [3/3]

Node capd::autodiff::operator+ ( double  x,
const Node &  y 
)

◆ operator+=() [1/2]

Node & capd::autodiff::operator+= ( Node &  x,
const Node &  y 
)

◆ operator+=() [2/2]

Node & capd::autodiff::operator+= ( Node &  x,
double  y 
)

◆ operator-() [1/4]

Node capd::autodiff::operator- ( const Node &  x)

◆ operator-() [2/4]

Node capd::autodiff::operator- ( const Node &  x,
const Node &  y 
)

◆ operator-() [3/4]

Node capd::autodiff::operator- ( const Node &  x,
double  y 
)

◆ operator-() [4/4]

Node capd::autodiff::operator- ( double  x,
const Node &  y 
)

◆ operator-=() [1/2]

Node & capd::autodiff::operator-= ( Node &  x,
const Node &  y 
)

◆ operator-=() [2/2]

Node & capd::autodiff::operator-= ( Node &  x,
double  y 
)

◆ operator/() [1/3]

Node capd::autodiff::operator/ ( const Node &  x,
const Node &  y 
)

◆ operator/() [2/3]

Node capd::autodiff::operator/ ( const Node &  x,
double  y 
)

◆ operator/() [3/3]

Node capd::autodiff::operator/ ( double  x,
const Node &  y 
)

◆ operator/=() [1/2]

Node & capd::autodiff::operator/= ( Node &  x,
const Node &  y 
)

◆ operator/=() [2/2]

Node & capd::autodiff::operator/= ( Node &  x,
double  y 
)

◆ operator^()

Node capd::autodiff::operator^ ( const Node &  x,
double  y 
)

◆ sin()

capd::autodiff::Node sin ( const capd::autodiff::Node &  x)

◆ sqr()

capd::autodiff::Node sqr ( const capd::autodiff::Node &  x)

◆ sqrt()

capd::autodiff::Node sqrt ( const capd::autodiff::Node &  x)

Variable Documentation

◆ dag

std::vector< capd::autodiff::Node > * capd::autodiff::Node::dag = 0
static