casadi::casadi_math< T > Struct Template Reference

Easy access to all the functions for a particular type. More...

#include <calculus.hpp>

Detailed Description

template<typename T>
struct casadi::casadi_math< T >

Definition at line 1125 of file calculus.hpp.

Static Public Member Functions
static void	fun (unsigned char op, const T &x, const T &y, T &f)
	Evaluate a built in function (scalar-scalar) More...
static void	fun (unsigned char op, const T *x, const T *y, T *f, casadi_int n)
	Evaluate a built in function (vector-vector) More...
static void	fun (unsigned char op, const T *x, const T &y, T *f, casadi_int n)
	Evaluate a built in function (vector-scalar) More...
static void	fun (unsigned char op, const T &x, const T *y, T *f, casadi_int n)
	Evaluate a built in function (scalar-vector) More...
static void	der (unsigned char op, const T &x, const T &y, const T &f, T *d)
	Evaluate a built in derivative function. More...
static void	derF (unsigned char op, const T &x, const T &y, T &f, T *d)
	Evaluate the function and the derivative function. More...
static void	fun_linear (unsigned char op, const T *x, const T *y, T *f)
	Evaluate function on a const/linear/nonlinear partition. More...
static bool	is_binary (unsigned char op)
	Is binary operation? More...
static bool	is_unary (unsigned char op)
	Is unary operation? More...
static casadi_int	ndeps (unsigned char op)
	Number of dependencies. More...
static std::string	print (unsigned char op, const std::string &x, const std::string &y)
	Print. More...
static std::string	print (unsigned char op, const std::string &x)
static std::string	name (unsigned char op)
static std::string	pre (unsigned char op)
static std::string	sep (unsigned char op)
static std::string	post (unsigned char op)

Member Function Documentation

der()

template<typename T >

void casadi::casadi_math< T >::der ( unsigned char  op, const T &  x, const T &  y, const T &  f, T *  d  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1ga

Definition at line 1375 of file calculus.hpp.

                                                                                            {
    // NOTE: We define the implementation in a preprocessor macro to be able to force inlining,
    // and to allow extensions in the VM
#define CASADI_MATH_DER_BUILTIN(X, Y, F, D)                             \
    case OP_ASSIGN:    BinaryOperation<OP_ASSIGN>::der(X, Y, F, D);     break; \
  case OP_ADD:       BinaryOperation<OP_ADD>::der(X, Y, F, D);        break; \
  case OP_SUB:       BinaryOperation<OP_SUB>::der(X, Y, F, D);        break; \
  case OP_MUL:       BinaryOperation<OP_MUL>::der(X, Y, F, D);        break; \
  case OP_DIV:       BinaryOperation<OP_DIV>::der(X, Y, F, D);        break; \
  case OP_NEG:       BinaryOperation<OP_NEG>::der(X, Y, F, D);        break; \
  case OP_EXP:       BinaryOperation<OP_EXP>::der(X, Y, F, D);        break; \
  case OP_LOG:       BinaryOperation<OP_LOG>::der(X, Y, F, D);        break; \
  case OP_POW:       BinaryOperation<OP_POW>::der(X, Y, F, D);        break; \
  case OP_CONSTPOW:  BinaryOperation<OP_CONSTPOW>::der(X, Y, F, D);   break; \
  case OP_SQRT:      BinaryOperation<OP_SQRT>::der(X, Y, F, D);       break; \
  case OP_SQ:        BinaryOperation<OP_SQ>::der(X, Y, F, D);         break; \
  case OP_TWICE:     BinaryOperation<OP_TWICE>::der(X, Y, F, D);      break; \
  case OP_SIN:       BinaryOperation<OP_SIN>::der(X, Y, F, D);        break; \
  case OP_COS:       BinaryOperation<OP_COS>::der(X, Y, F, D);        break; \
  case OP_TAN:       BinaryOperation<OP_TAN>::der(X, Y, F, D);        break; \
  case OP_ASIN:      BinaryOperation<OP_ASIN>::der(X, Y, F, D);       break; \
  case OP_ACOS:      BinaryOperation<OP_ACOS>::der(X, Y, F, D);       break; \
  case OP_ATAN:      BinaryOperation<OP_ATAN>::der(X, Y, F, D);       break; \
  case OP_LT:        BinaryOperation<OP_LT>::der(X, Y, F, D);         break; \
  case OP_LE:        BinaryOperation<OP_LE>::der(X, Y, F, D);         break; \
  case OP_EQ:        BinaryOperation<OP_EQ>::der(X, Y, F, D);         break; \
  case OP_NE:        BinaryOperation<OP_NE>::der(X, Y, F, D);         break; \
  case OP_NOT:       BinaryOperation<OP_NOT>::der(X, Y, F, D);        break; \
  case OP_AND:       BinaryOperation<OP_AND>::der(X, Y, F, D);        break; \
  case OP_OR:        BinaryOperation<OP_OR>::der(X, Y, F, D);         break; \
  case OP_IF_ELSE_ZERO: BinaryOperation<OP_IF_ELSE_ZERO>::der(X, Y, F, D);         break; \
  case OP_FLOOR:     BinaryOperation<OP_FLOOR>::der(X, Y, F, D);      break; \
  case OP_CEIL:      BinaryOperation<OP_CEIL>::der(X, Y, F, D);       break; \
  case OP_FMOD:      BinaryOperation<OP_FMOD>::der(X, Y, F, D);       break; \
  case OP_REMAINDER: BinaryOperation<OP_REMAINDER>::der(X, Y, F, D);  break; \
  case OP_FABS:      BinaryOperation<OP_FABS>::der(X, Y, F, D);       break; \
  case OP_SIGN:      BinaryOperation<OP_SIGN>::der(X, Y, F, D);       break; \
  case OP_COPYSIGN:  BinaryOperation<OP_COPYSIGN>::der(X, Y, F, D);   break; \
  case OP_ERF:       BinaryOperation<OP_ERF>::der(X, Y, F, D);        break; \
  case OP_FMIN:      BinaryOperation<OP_FMIN>::der(X, Y, F, D);       break; \
  case OP_FMAX:      BinaryOperation<OP_FMAX>::der(X, Y, F, D);       break; \
  case OP_INV:       BinaryOperation<OP_INV>::der(X, Y, F, D);        break; \
  case OP_SINH:      BinaryOperation<OP_SINH>::der(X, Y, F, D);       break; \
  case OP_COSH:      BinaryOperation<OP_COSH>::der(X, Y, F, D);       break; \
  case OP_TANH:      BinaryOperation<OP_TANH>::der(X, Y, F, D);       break; \
  case OP_ASINH:     BinaryOperation<OP_ASINH>::der(X, Y, F, D);      break; \
  case OP_ACOSH:     BinaryOperation<OP_ACOSH>::der(X, Y, F, D);      break; \
  case OP_ATANH:     BinaryOperation<OP_ATANH>::der(X, Y, F, D);      break; \
  case OP_ATAN2:     BinaryOperation<OP_ATAN2>::der(X, Y, F, D);      break; \
  case OP_ERFINV:    BinaryOperation<OP_ERFINV>::der(X, Y, F, D);     break; \
  case OP_LIFT:      BinaryOperation<OP_LIFT>::der(X, Y, F, D);       break; \
  case OP_PRINTME:   BinaryOperation<OP_PRINTME>::der(X, Y, F, D);    break; \
  case OP_LOG1P:     BinaryOperation<OP_LOG1P>::der(X, Y, F, D);      break; \
  case OP_EXPM1:     BinaryOperation<OP_EXPM1>::der(X, Y, F, D);      break; \
  case OP_HYPOT:     BinaryOperation<OP_HYPOT>::der(X, Y, F, D);      break;
    switch (op) {
    CASADI_MATH_DER_BUILTIN(x, y, f, d)
      }
  }

Referenced by casadi::BinaryMX< ScX, ScY >::ad_forward(), casadi::UnaryMX::ad_forward(), casadi::BinaryMX< ScX, ScY >::ad_reverse(), casadi::UnaryMX::ad_reverse(), and casadi::casadi_math< casadi_int >::der().

derF()

template<typename T >

void casadi::casadi_math< T >::derF ( unsigned char  op, const T &  x, const T &  y, T &  f, T *  d  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1gb

Definition at line 1437 of file calculus.hpp.

                                                                                           {
    // NOTE: We define the implementation in a preprocessor macro to be able to force inlining,
    // and to allow extensions in the VM
#define CASADI_MATH_DERF_BUILTIN(X, Y, F, D)                            \
case OP_ASSIGN:    DerBinaryOperation<OP_ASSIGN>::derf(X, Y, F, D);        break; \
case OP_ADD:       DerBinaryOperation<OP_ADD>::derf(X, Y, F, D);        break; \
case OP_SUB:       DerBinaryOperation<OP_SUB>::derf(X, Y, F, D);        break; \
case OP_MUL:       DerBinaryOperation<OP_MUL>::derf(X, Y, F, D);        break; \
case OP_DIV:       DerBinaryOperation<OP_DIV>::derf(X, Y, F, D);        break; \
case OP_NEG:       DerBinaryOperation<OP_NEG>::derf(X, Y, F, D);        break; \
case OP_EXP:       DerBinaryOperation<OP_EXP>::derf(X, Y, F, D);        break; \
case OP_LOG:       DerBinaryOperation<OP_LOG>::derf(X, Y, F, D);        break; \
case OP_POW:       DerBinaryOperation<OP_POW>::derf(X, Y, F, D);        break; \
case OP_CONSTPOW:  DerBinaryOperation<OP_CONSTPOW>::derf(X, Y, F, D);   break; \
case OP_SQRT:      DerBinaryOperation<OP_SQRT>::derf(X, Y, F, D);       break; \
case OP_SQ:        DerBinaryOperation<OP_SQ>::derf(X, Y, F, D);         break; \
case OP_TWICE:     DerBinaryOperation<OP_TWICE>::derf(X, Y, F, D);      break; \
case OP_SIN:       DerBinaryOperation<OP_SIN>::derf(X, Y, F, D);        break; \
case OP_COS:       DerBinaryOperation<OP_COS>::derf(X, Y, F, D);        break; \
case OP_TAN:       DerBinaryOperation<OP_TAN>::derf(X, Y, F, D);        break; \
case OP_ASIN:      DerBinaryOperation<OP_ASIN>::derf(X, Y, F, D);       break; \
case OP_ACOS:      DerBinaryOperation<OP_ACOS>::derf(X, Y, F, D);       break; \
case OP_ATAN:      DerBinaryOperation<OP_ATAN>::derf(X, Y, F, D);       break; \
case OP_LT:        DerBinaryOperation<OP_LT>::derf(X, Y, F, D);         break; \
case OP_LE:        DerBinaryOperation<OP_LE>::derf(X, Y, F, D);         break; \
case OP_EQ:        DerBinaryOperation<OP_EQ>::derf(X, Y, F, D);         break; \
case OP_NE:        DerBinaryOperation<OP_NE>::derf(X, Y, F, D);         break; \
case OP_NOT:       DerBinaryOperation<OP_NOT>::derf(X, Y, F, D);        break; \
case OP_AND:       DerBinaryOperation<OP_AND>::derf(X, Y, F, D);        break; \
case OP_OR:        DerBinaryOperation<OP_OR>::derf(X, Y, F, D);         break; \
case OP_IF_ELSE_ZERO: DerBinaryOperation<OP_IF_ELSE_ZERO>::derf(X, Y, F, D);         break; \
case OP_FLOOR:     DerBinaryOperation<OP_FLOOR>::derf(X, Y, F, D);      break; \
case OP_CEIL:      DerBinaryOperation<OP_CEIL>::derf(X, Y, F, D);       break; \
case OP_FMOD:      DerBinaryOperation<OP_FMOD>::derf(X, Y, F, D);       break; \
case OP_REMAINDER: DerBinaryOperation<OP_REMAINDER>::derf(X, Y, F, D);   break; \
case OP_FABS:      DerBinaryOperation<OP_FABS>::derf(X, Y, F, D);       break; \
case OP_SIGN:      DerBinaryOperation<OP_SIGN>::derf(X, Y, F, D);       break; \
case OP_COPYSIGN:  DerBinaryOperation<OP_COPYSIGN>::derf(X, Y, F, D);   break; \
case OP_ERF:       DerBinaryOperation<OP_ERF>::derf(X, Y, F, D);        break; \
case OP_FMIN:      DerBinaryOperation<OP_FMIN>::derf(X, Y, F, D);       break; \
case OP_FMAX:      DerBinaryOperation<OP_FMAX>::derf(X, Y, F, D);       break; \
case OP_INV:       DerBinaryOperation<OP_INV>::derf(X, Y, F, D);        break; \
case OP_SINH:      DerBinaryOperation<OP_SINH>::derf(X, Y, F, D);       break; \
case OP_COSH:      DerBinaryOperation<OP_COSH>::derf(X, Y, F, D);       break; \
case OP_TANH:      DerBinaryOperation<OP_TANH>::derf(X, Y, F, D);       break; \
case OP_ASINH:     DerBinaryOperation<OP_ASINH>::derf(X, Y, F, D);      break; \
case OP_ACOSH:     DerBinaryOperation<OP_ACOSH>::derf(X, Y, F, D);      break; \
case OP_ATANH:     DerBinaryOperation<OP_ATANH>::derf(X, Y, F, D);      break; \
case OP_ATAN2:     DerBinaryOperation<OP_ATAN2>::derf(X, Y, F, D);      break; \
case OP_ERFINV:    DerBinaryOperation<OP_ERFINV>::derf(X, Y, F, D);     break; \
case OP_LIFT:      DerBinaryOperation<OP_LIFT>::derf(X, Y, F, D);       break; \
case OP_PRINTME:   DerBinaryOperation<OP_PRINTME>::derf(X, Y, F, D);    break; \
case OP_LOG1P:     DerBinaryOperation<OP_LOG1P>::derf(X, Y, F, D);      break; \
case OP_EXPM1:     DerBinaryOperation<OP_EXPM1>::derf(X, Y, F, D);      break; \
case OP_HYPOT:     DerBinaryOperation<OP_HYPOT>::derf(X, Y, F, D);      break;
    switch (op) {
      CASADI_MATH_DERF_BUILTIN(x, y, f, d)
        }
  }

Referenced by casadi::casadi_math< casadi_int >::derF().

fun() [1/4]

template<typename T >

void casadi::casadi_math< T >::fun ( unsigned char  op, const T &  x, const T &  y, T &  f  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1g6

Definition at line 1289 of file calculus.hpp.

                                                                                {
    // NOTE: We define the implementation in a preprocessor macro to be able to force inlining,
    //  and to allow extensions in the VM
#define CASADI_MATH_FUN_BUILTIN_GEN(CNAME, X, Y, F, N)                  \
    case OP_ASSIGN:    CNAME<OP_ASSIGN>::fcn(X, Y, F, N);        break; \
  case OP_ADD:       CNAME<OP_ADD>::fcn(X, Y, F, N);           break;   \
  case OP_SUB:       CNAME<OP_SUB>::fcn(X, Y, F, N);           break;   \
  case OP_MUL:       CNAME<OP_MUL>::fcn(X, Y, F, N);           break;   \
  case OP_DIV:       CNAME<OP_DIV>::fcn(X, Y, F, N);           break;   \
  case OP_NEG:       CNAME<OP_NEG>::fcn(X, Y, F, N);           break;   \
  case OP_EXP:       CNAME<OP_EXP>::fcn(X, Y, F, N);           break;   \
  case OP_LOG:       CNAME<OP_LOG>::fcn(X, Y, F, N);           break;   \
  case OP_POW:       CNAME<OP_POW>::fcn(X, Y, F, N);           break;   \
  case OP_CONSTPOW:  CNAME<OP_CONSTPOW>::fcn(X, Y, F, N);      break;   \
  case OP_SQRT:      CNAME<OP_SQRT>::fcn(X, Y, F, N);          break;   \
  case OP_SQ:        CNAME<OP_SQ>::fcn(X, Y, F, N);            break;   \
  case OP_TWICE:     CNAME<OP_TWICE>::fcn(X, Y, F, N);         break;   \
  case OP_SIN:       CNAME<OP_SIN>::fcn(X, Y, F, N);           break;   \
  case OP_COS:       CNAME<OP_COS>::fcn(X, Y, F, N);           break;   \
  case OP_TAN:       CNAME<OP_TAN>::fcn(X, Y, F, N);           break;   \
  case OP_ASIN:      CNAME<OP_ASIN>::fcn(X, Y, F, N);          break;   \
  case OP_ACOS:      CNAME<OP_ACOS>::fcn(X, Y, F, N);          break;   \
  case OP_ATAN:      CNAME<OP_ATAN>::fcn(X, Y, F, N);          break;   \
  case OP_LT:        CNAME<OP_LT>::fcn(X, Y, F, N);            break;   \
  case OP_LE:        CNAME<OP_LE>::fcn(X, Y, F, N);            break;   \
  case OP_EQ:        CNAME<OP_EQ>::fcn(X, Y, F, N);            break;   \
  case OP_NE:        CNAME<OP_NE>::fcn(X, Y, F, N);            break;   \
  case OP_NOT:       CNAME<OP_NOT>::fcn(X, Y, F, N);           break;   \
  case OP_AND:       CNAME<OP_AND>::fcn(X, Y, F, N);           break;   \
  case OP_OR:        CNAME<OP_OR>::fcn(X, Y, F, N);            break;   \
  case OP_IF_ELSE_ZERO: CNAME<OP_IF_ELSE_ZERO>::fcn(X, Y, F, N); break; \
  case OP_FLOOR:     CNAME<OP_FLOOR>::fcn(X, Y, F, N);         break;   \
  case OP_CEIL:      CNAME<OP_CEIL>::fcn(X, Y, F, N);          break;   \
  case OP_FMOD:      CNAME<OP_FMOD>::fcn(X, Y, F, N);          break;   \
  case OP_REMAINDER: CNAME<OP_REMAINDER>::fcn(X, Y, F, N);     break;   \
  case OP_FABS:      CNAME<OP_FABS>::fcn(X, Y, F, N);          break;   \
  case OP_SIGN:      CNAME<OP_SIGN>::fcn(X, Y, F, N);          break;   \
  case OP_COPYSIGN:  CNAME<OP_COPYSIGN>::fcn(X, Y, F, N);      break;   \
  case OP_ERF:       CNAME<OP_ERF>::fcn(X, Y, F, N);           break;   \
  case OP_FMIN:      CNAME<OP_FMIN>::fcn(X, Y, F, N);          break;   \
  case OP_FMAX:      CNAME<OP_FMAX>::fcn(X, Y, F, N);          break;   \
  case OP_INV:       CNAME<OP_INV>::fcn(X, Y, F, N);           break;   \
  case OP_SINH:      CNAME<OP_SINH>::fcn(X, Y, F, N);          break;   \
  case OP_COSH:      CNAME<OP_COSH>::fcn(X, Y, F, N);          break;   \
  case OP_TANH:      CNAME<OP_TANH>::fcn(X, Y, F, N);          break;   \
  case OP_ASINH:     CNAME<OP_ASINH>::fcn(X, Y, F, N);         break;   \
  case OP_ACOSH:     CNAME<OP_ACOSH>::fcn(X, Y, F, N);         break;   \
  case OP_ATANH:     CNAME<OP_ATANH>::fcn(X, Y, F, N);         break;   \
  case OP_ATAN2:     CNAME<OP_ATAN2>::fcn(X, Y, F, N);         break;   \
  case OP_ERFINV:    CNAME<OP_ERFINV>::fcn(X, Y, F, N);        break;   \
  case OP_LIFT:      CNAME<OP_LIFT>::fcn(X, Y, F, N);          break;   \
  case OP_PRINTME:   CNAME<OP_PRINTME>::fcn(X, Y, F, N);       break;   \
  case OP_LOG1P:     CNAME<OP_LOG1P>::fcn(X, Y, F, N);       break;   \
  case OP_EXPM1:     CNAME<OP_EXPM1>::fcn(X, Y, F, N);       break;   \
  case OP_HYPOT:     CNAME<OP_HYPOT>::fcn(X, Y, F, N);       break;
 
#define CASADI_MATH_FUN_BUILTIN(X, Y, F) CASADI_MATH_FUN_BUILTIN_GEN(BinaryOperationSS, X, Y, F, 1)
 
    switch (op) {
    CASADI_MATH_FUN_BUILTIN(x, y, f)
      }
  }

Referenced by casadi::MXNode::_get_binary(), casadi::Constant< Value >::_get_binary(), casadi::UnarySX::create(), casadi::BinarySX::create(), casadi::UnaryMX::eval(), casadi::BinaryMX< ScX, ScY >::eval_gen(), casadi::BinaryMX< ScX, ScY >::eval_mx(), casadi::UnaryMX::eval_mx(), casadi::UnaryMX::eval_sx(), casadi::casadi_math< casadi_int >::fun(), and casadi::Constant< Value >::get_unary().

fun() [2/4]

template<typename T >

void casadi::casadi_math< T >::fun ( unsigned char  op, const T &  x, const T *  y, T *  f, casadi_int  n  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1g9

Definition at line 1367 of file calculus.hpp.

                                                                                              {
    switch (op) {
      CASADI_MATH_FUN_BUILTIN_GEN(BinaryOperationSV, x, y, f, n)
        }
  }

fun() [3/4]

template<typename T >

void casadi::casadi_math< T >::fun ( unsigned char  op, const T *  x, const T &  y, T *  f, casadi_int  n  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1g8

Definition at line 1360 of file calculus.hpp.

                                                                                              {
    switch (op) {
      CASADI_MATH_FUN_BUILTIN_GEN(BinaryOperationVS, x, y, f, n)
        }
  }

fun() [4/4]

template<typename T >

void casadi::casadi_math< T >::fun ( unsigned char  op, const T *  x, const T *  y, T *  f, casadi_int  n  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1g7

Definition at line 1353 of file calculus.hpp.

                                                                                              {
    switch (op) {
      CASADI_MATH_FUN_BUILTIN_GEN(BinaryOperationVV, x, y, f, n)
        }
  }

fun_linear()

template<typename T >

void casadi::casadi_math< T >::fun_linear ( unsigned char  op, const T *  x, const T *  y, T *  f  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_28f

Definition at line 1552 of file calculus.hpp.

                                                                                       {
    if (op==OP_ADD || op==OP_SUB) {
      for (int i=0;i<3;++i) {
        f[i] = T::binary(op, x[i], y[i]);
      }
    } else if (op==OP_TWICE || op==OP_NEG) {
      for (int i=0;i<3;++i) {
        f[i] = T::unary(op, x[i]);
      }
    } else if (op==OP_MUL) {
      f[0] += x[0]*y[0];
      f[1] += x[0]*y[1];
      f[2] += x[0]*y[2];
      f[1] += x[1]*y[0];
      f[2] += x[1]*y[1];
      f[2] += x[1]*y[2];
      f[2] += x[2]*y[0];
      f[2] += x[2]*y[1];
      f[2] += x[2]*y[2];
    } else if (op==OP_DIV) {
      bool const_argy = y[1].is_zero() && y[2].is_zero();
      if (const_argy) {
        f[0] = x[0]/y[0];
        f[1] = x[1]/y[0];
        f[2] = x[2]/y[0];
      } else {
        f[2] = (x[0]+x[1]+x[2])/(y[0]+y[1]+y[2]);
      }
    } else if (casadi_math<T>::is_unary(op)) {
      bool const_arg = x[1].is_zero() && x[2].is_zero();
      if (const_arg) {
        f[0] = T::unary(op, x[0]);
      } else {
        f[2] = T::unary(op, x[0]+x[1]+x[2]);
      }
 
    } else if (casadi_math<T>::is_binary(op)) {
      bool const_argx = x[1].is_zero() && x[2].is_zero();
      bool const_argy = y[1].is_zero() && y[2].is_zero();
      if (const_argx && const_argy) {
        f[0] = T::binary(op, x[0], y[0]);
      } else {
        f[2] = T::binary(op, x[0]+x[1]+x[2], y[0]+y[1]+y[2]);
      }
    } else {
      casadi_error("Not implemented");
    }
  }

References casadi::OP_ADD, casadi::OP_DIV, casadi::OP_MUL, casadi::OP_NEG, casadi::OP_SUB, and casadi::OP_TWICE.

Referenced by casadi::BinaryMX< ScX, ScY >::eval_linear(), and casadi::UnaryMX::eval_linear().

is_binary()

template<typename T >

bool casadi::casadi_math< T >::is_binary ( unsigned char  op )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1gc

Definition at line 1602 of file calculus.hpp.

                                                 {
    switch (op) {
      CASADI_MATH_BINARY_BUILTIN
      case OP_IF_ELSE_ZERO:
        return true;
      default:
        return false;
    }
  }

References casadi::OP_IF_ELSE_ZERO.

is_unary()

template<typename T >

bool casadi::casadi_math< T >::is_unary ( unsigned char  op )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1gd

Definition at line 1613 of file calculus.hpp.

                                                {
    switch (op) {
      CASADI_MATH_UNARY_BUILTIN
      return true;
    default:
      return false;
    }
  }

name()

template<typename T >

std::string casadi::casadi_math< T >::name ( unsigned char  op )

inlinestatic

Definition at line 1655 of file calculus.hpp.

                                                        {
    switch (op) {
    case OP_ASSIGN:         return "assign";
    case OP_ADD:            return "add";
    case OP_SUB:            return "sub";
    case OP_MUL:            return "mul";
    case OP_DIV:            return "div";
    case OP_NEG:            return "neg";
    case OP_EXP:            return "exp";
    case OP_LOG:            return "log";
    case OP_CONSTPOW:
    case OP_POW:            return "pow";
    case OP_SQRT:           return "sqrt";
    case OP_SQ:             return "sq";
    case OP_TWICE:          return "twice";
    case OP_SIN:            return "sin";
    case OP_COS:            return "cos";
    case OP_TAN:            return "tan";
    case OP_ASIN:           return "asin";
    case OP_ACOS:           return "acos";
    case OP_ATAN:           return "atan";
    case OP_LT:             return "lt";
    case OP_LE:             return "le";
    case OP_EQ:             return "eq";
    case OP_NE:             return "ne";
    case OP_NOT:            return "not";
    case OP_AND:            return "and";
    case OP_OR:             return "or";
    case OP_FLOOR:          return "floor";
    case OP_CEIL:           return "ceil";
    case OP_FMOD:           return "fmod";
    case OP_REMAINDER:      return "remainder";
    case OP_FABS:           return "fabs";
    case OP_SIGN:           return "sign";
    case OP_COPYSIGN:       return "copysign";
    case OP_IF_ELSE_ZERO:   return "if_else_zero";
    case OP_ERF:            return "erf";
    case OP_FMIN:           return "fmin";
    case OP_FMAX:           return "fmax";
    case OP_INV:            return "inv";
    case OP_SINH:           return "sinh";
    case OP_COSH:           return "cosh";
    case OP_TANH:           return "tanh";
    case OP_ASINH:          return "asinh";
    case OP_ACOSH:          return "acosh";
    case OP_ATANH:          return "atanh";
    case OP_ATAN2:          return "atan2";
    case OP_CONST:          return "const";
    case OP_INPUT:          return "input";
    case OP_OUTPUT:         return "output";
    case OP_PARAMETER:      return "parameter";
    case OP_CALL:           return "call";
    case OP_MTIMES:         return "mtimes";
    case OP_SOLVE:          return "solve";
    case OP_TRANSPOSE:      return "transpose";
    case OP_DETERMINANT:    return "determinant";
    case OP_INVERSE:        return "inverse";
    case OP_DOT:            return "dot";
    case OP_HORZCAT:        return "horzcat";
    case OP_VERTCAT:        return "vertcat";
    case OP_DIAGCAT:        return "diagcat";
    case OP_HORZSPLIT:      return "horzsplit";
    case OP_VERTSPLIT:      return "vertsplit";
    case OP_DIAGSPLIT:      return "diagsplit";
    case OP_RESHAPE:        return "reshape";
    case OP_SPARSITY_CAST:  return "sparsity_cast";
    case OP_SUBREF:         return "subref";
    case OP_SUBASSIGN:      return "subassign";
    case OP_GETNONZEROS:    return "getnonzeros";
    case OP_GETNONZEROS_PARAM:    return "getnonzeros_param";
    case OP_ADDNONZEROS:    return "addnonzeros";
    case OP_ADDNONZEROS_PARAM:    return "addnonzeros_param";
    case OP_SETNONZEROS:    return "setnonzeros";
    case OP_SETNONZEROS_PARAM:    return "setnonzeros_param";
    case OP_PROJECT:        return "project";
    case OP_ASSERTION:      return "assertion";
    case OP_NORM2:          return "norm2";
    case OP_NORM1:          return "norm1";
    case OP_NORMINF:        return "norminf";
    case OP_NORMF:          return "normf";
    case OP_ERFINV:         return "erfinv";
    case OP_PRINTME:        return "printme";
    case OP_LIFT:           return "lift";
    case OP_EINSTEIN:       return "einstein";
    case OP_BSPLINE:        return "bspline";
    case OP_CONVEXIFY:      return "convexify";
    case OP_LOG1P:          return "log1p";
    case OP_EXPM1:          return "expm1";
    case OP_HYPOT:          return "hypot";
    case OP_LOGSUMEXP:      return "logsumexp";
    }
    return "<invalid-op>";
  }

References casadi::OP_ACOS, casadi::OP_ACOSH, casadi::OP_ADD, casadi::OP_ADDNONZEROS, casadi::OP_ADDNONZEROS_PARAM, casadi::OP_AND, casadi::OP_ASIN, casadi::OP_ASINH, casadi::OP_ASSERTION, casadi::OP_ASSIGN, casadi::OP_ATAN, casadi::OP_ATAN2, casadi::OP_ATANH, casadi::OP_BSPLINE, casadi::OP_CALL, casadi::OP_CEIL, casadi::OP_CONST, casadi::OP_CONSTPOW, casadi::OP_CONVEXIFY, casadi::OP_COPYSIGN, casadi::OP_COS, casadi::OP_COSH, casadi::OP_DETERMINANT, casadi::OP_DIAGCAT, casadi::OP_DIAGSPLIT, casadi::OP_DIV, casadi::OP_DOT, casadi::OP_EINSTEIN, casadi::OP_EQ, casadi::OP_ERF, casadi::OP_ERFINV, casadi::OP_EXP, casadi::OP_EXPM1, casadi::OP_FABS, casadi::OP_FLOOR, casadi::OP_FMAX, casadi::OP_FMIN, casadi::OP_FMOD, casadi::OP_GETNONZEROS, casadi::OP_GETNONZEROS_PARAM, casadi::OP_HORZCAT, casadi::OP_HORZSPLIT, casadi::OP_HYPOT, casadi::OP_IF_ELSE_ZERO, casadi::OP_INPUT, casadi::OP_INV, casadi::OP_INVERSE, casadi::OP_LE, casadi::OP_LIFT, casadi::OP_LOG, casadi::OP_LOG1P, casadi::OP_LOGSUMEXP, casadi::OP_LT, casadi::OP_MTIMES, casadi::OP_MUL, casadi::OP_NE, casadi::OP_NEG, casadi::OP_NORM1, casadi::OP_NORM2, casadi::OP_NORMF, casadi::OP_NORMINF, casadi::OP_NOT, casadi::OP_OR, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::OP_POW, casadi::OP_PRINTME, casadi::OP_PROJECT, casadi::OP_REMAINDER, casadi::OP_RESHAPE, casadi::OP_SETNONZEROS, casadi::OP_SETNONZEROS_PARAM, casadi::OP_SIGN, casadi::OP_SIN, casadi::OP_SINH, casadi::OP_SOLVE, casadi::OP_SPARSITY_CAST, casadi::OP_SQ, casadi::OP_SQRT, casadi::OP_SUB, casadi::OP_SUBASSIGN, casadi::OP_SUBREF, casadi::OP_TAN, casadi::OP_TANH, casadi::OP_TRANSPOSE, casadi::OP_TWICE, casadi::OP_VERTCAT, and casadi::OP_VERTSPLIT.

Referenced by casadi::casadi_math< casadi_int >::name().

ndeps()

template<typename T >

casadi_int casadi::casadi_math< T >::ndeps ( unsigned char  op )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1ge

Definition at line 1623 of file calculus.hpp.

                                                          {
    switch (op) {
      case OP_CONST:
      case OP_PARAMETER:
      case OP_INPUT:
        return 0;
      CASADI_MATH_BINARY_BUILTIN
      case OP_IF_ELSE_ZERO:
        return 2;
      case OP_CALL:
        return -1;
      default:
        return 1;
    }
  }

References casadi::OP_CALL, casadi::OP_CONST, casadi::OP_IF_ELSE_ZERO, casadi::OP_INPUT, and casadi::OP_PARAMETER.

Referenced by casadi::SXFunction::codegen_body(), casadi::SXFunction::disp_more(), casadi::SXFunction::init(), and casadi::casadi_math< casadi_int >::ndeps().

post()

template<typename T >

std::string casadi::casadi_math< T >::post ( unsigned char  op )

inlinestatic

Definition at line 1791 of file calculus.hpp.

                                                        {
    switch (op) {
    case OP_ASSIGN:       return "";
    case OP_IF_ELSE_ZERO: return ":0)";
    default:              return ")";
    }
  }

References casadi::OP_ASSIGN, and casadi::OP_IF_ELSE_ZERO.

Referenced by casadi::casadi_math< casadi_int >::post().

pre()

template<typename T >

std::string casadi::casadi_math< T >::pre ( unsigned char  op )

inlinestatic

Definition at line 1750 of file calculus.hpp.

                                                       {
    switch (op) {
    case OP_ASSIGN:    return "";
    case OP_ADD:       return "(";
    case OP_SUB:       return "(";
    case OP_MUL:       return "(";
    case OP_DIV:       return "(";
    case OP_NEG:       return "(-";
    case OP_TWICE:     return "(2.*";
    case OP_LT:        return "(";
    case OP_LE:        return "(";
    case OP_EQ:        return "(";
    case OP_NE:        return "(";
    case OP_NOT:       return "(!";
    case OP_AND:       return "(";
    case OP_OR:        return "(";
    case OP_IF_ELSE_ZERO: return "(";
    case OP_INV:       return "(1./";
    default: return name(op) + "(";
    }
  }

References casadi::OP_ADD, casadi::OP_AND, casadi::OP_ASSIGN, casadi::OP_DIV, casadi::OP_EQ, casadi::OP_IF_ELSE_ZERO, casadi::OP_INV, casadi::OP_LE, casadi::OP_LT, casadi::OP_MUL, casadi::OP_NE, casadi::OP_NEG, casadi::OP_NOT, casadi::OP_OR, casadi::OP_SUB, and casadi::OP_TWICE.

Referenced by casadi::casadi_math< casadi_int >::pre().

print() [1/2]

template<typename T >

std::string casadi::casadi_math< T >::print ( unsigned char  op, const std::string &  x  )

inlinestatic

Definition at line 1649 of file calculus.hpp.

                                                            {
    casadi_assert_dev(ndeps(op)==1);
    return pre(op) + x + post(op);
  }

print() [2/2]

template<typename T >

std::string casadi::casadi_math< T >::print ( unsigned char  op, const std::string &  x, const std::string &  y  )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_1gf

Definition at line 1641 of file calculus.hpp.

                                                                {
    casadi_assert_dev(ndeps(op)==2);
    return pre(op) + x + sep(op) + y + post(op);
  }

Referenced by casadi::BinaryMX< ScX, ScY >::disp(), casadi::UnaryMX::disp(), casadi::MXFunction::export_code_body(), casadi::SXFunction::export_code_body(), casadi::BinarySX::print(), casadi::UnarySX::print(), casadi::casadi_math< casadi_int >::print(), and casadi::CodeGenerator::print_op().

sep()

template<typename T >

std::string casadi::casadi_math< T >::sep ( unsigned char  op )

inlinestatic

Definition at line 1773 of file calculus.hpp.

                                                       {
    switch (op) {
    case OP_ADD:       return "+";
    case OP_SUB:       return "-";
    case OP_MUL:       return "*";
    case OP_DIV:       return "/";
    case OP_LT:        return "<";
    case OP_LE:        return "<=";
    case OP_EQ:        return "==";
    case OP_NE:        return "!=";
    case OP_AND:       return "&&";
    case OP_OR:        return "||";
    case OP_IF_ELSE_ZERO: return "?";
    default:           return ",";
    }
  }

References casadi::OP_ADD, casadi::OP_AND, casadi::OP_DIV, casadi::OP_EQ, casadi::OP_IF_ELSE_ZERO, casadi::OP_LE, casadi::OP_LT, casadi::OP_MUL, casadi::OP_NE, casadi::OP_OR, and casadi::OP_SUB.

Referenced by casadi::casadi_math< casadi_int >::sep().

---

The documentation for this struct was generated from the following file:

• calculus.hpp