Logo  0.95.0-final
Finite Element Embedded Library and Language in C++
Feel++ Feel++ on Github Feel++ community
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
adbinaryoperators.hpp File Reference

Go to the source code of this file.

Functions

template<class E1 , class E2 >
ADExpr< ADBinaryNotEqual
< ADExpr< E1 >, ADExpr< E2 > > > 
operator!= (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryNotEqual
< ADExpr< E >, ADType
< typename E::value_type, Nvar,
order, Var > > > 
operator!= (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryNotEqual
< ADType< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator!= (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryNotEqual
< ADType< typename
E::value_type, Nvar, order,
Var >, ADExpr< E > > > 
operator!= (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryNotEqual
< ADCst< C >, ADType< A, Nvar,
order, Var > > > 
operator!= (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryNotEqual
< ADType< A, Nvar, order, Var >
, ADCst< C > > > 
operator!= (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryNotEqual
< ADCst< C >, ADExpr< E > > > 
operator!= (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryNotEqual
< ADExpr< E >, ADCst< C > > > 
operator!= (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryMultiply
< ADExpr< E1 >, ADExpr< E2 > > > 
operator* (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryMultiply
< ADExpr< E >, ADType
< typename E::value_type, Nvar,
order, Var > > > 
operator* (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryMultiply
< ADType< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator* (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryMultiply
< ADType< typename
E::value_type, Nvar, order,
Var >, ADExpr< E > > > 
operator* (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryMultiply
< ADCst< C >, ADType< A, Nvar,
order, Var > > > 
operator* (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryMultiply
< ADType< A, Nvar, order, Var >
, ADCst< C > > > 
operator* (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryMultiply
< ADCst< C >, ADExpr< E > > > 
operator* (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryMultiply
< ADExpr< E >, ADCst< C > > > 
operator* (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryAdd< ADExpr
< E1 >, ADExpr< E2 > > > 
operator+ (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryAdd< ADExpr< E >
, ADType< typename
E::value_type, Nvar, order,
Var > > > 
operator+ (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryAdd< ADType< A,
Nvar, order, Var1 >, ADType< A,
Nvar, order, Var2 > > > 
operator+ (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryAdd< ADType
< typename E::value_type, Nvar,
order, Var >, ADExpr< E > > > 
operator+ (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryAdd< ADCst< C >
, ADType< A, Nvar, order, Var > > > 
operator+ (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryAdd< ADType< A,
Nvar, order, Var >, ADCst< C > > > 
operator+ (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryAdd< ADCst< C >
, ADExpr< E > > > 
operator+ (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryAdd< ADExpr< E >
, ADCst< C > > > 
operator+ (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinarySubtract
< ADExpr< E1 >, ADExpr< E2 > > > 
operator- (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinarySubtract
< ADExpr< E >, ADType
< typename E::value_type, Nvar,
order, Var > > > 
operator- (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinarySubtract
< ADType< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator- (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinarySubtract
< ADType< typename
E::value_type, Nvar, order,
Var >, ADExpr< E > > > 
operator- (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinarySubtract
< ADCst< C >, ADType< A, Nvar,
order, Var > > > 
operator- (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinarySubtract
< ADType< A, Nvar, order, Var >
, ADCst< C > > > 
operator- (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinarySubtract
< ADCst< C >, ADExpr< E > > > 
operator- (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinarySubtract
< ADExpr< E >, ADCst< C > > > 
operator- (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryDivide< ADExpr
< E1 >, ADExpr< E2 > > > 
operator/ (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryDivide< ADExpr
< E >, ADType< typename
E::value_type, Nvar, order,
Var > > > 
operator/ (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryDivide< ADType
< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator/ (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryDivide< ADType
< typename E::value_type, Nvar,
order, Var >, ADExpr< E > > > 
operator/ (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryDivide< ADCst
< C >, ADType< A, Nvar, order,
Var > > > 
operator/ (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryDivide< ADType
< A, Nvar, order, Var >, ADCst
< C > > > 
operator/ (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryDivide< ADCst
< C >, ADExpr< E > > > 
operator/ (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryDivide< ADExpr
< E >, ADCst< C > > > 
operator/ (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryLess< ADExpr
< E1 >, ADExpr< E2 > > > 
operator< (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryLess< ADExpr
< E >, ADType< typename
E::value_type, Nvar, order,
Var > > > 
operator< (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryLess< ADType
< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator< (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryLess< ADType
< typename E::value_type, Nvar,
order, Var >, ADExpr< E > > > 
operator< (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryLess< ADCst< C >
, ADType< A, Nvar, order, Var > > > 
operator< (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryLess< ADType
< A, Nvar, order, Var >, ADCst
< C > > > 
operator< (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryLess< ADCst< C >
, ADExpr< E > > > 
operator< (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryLess< ADExpr
< E >, ADCst< C > > > 
operator< (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryLessOrEqual
< ADExpr< E1 >, ADExpr< E2 > > > 
operator<= (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryLessOrEqual
< ADExpr< E >, ADType
< typename E::value_type, Nvar,
order, Var > > > 
operator<= (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryLessOrEqual
< ADType< typename
E::value_type, Nvar, order,
Var >, ADExpr< E > > > 
operator<= (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryLessOrEqual
< ADCst< C >, ADType< A, Nvar,
order, Var > > > 
operator<= (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryLessOrEqual
< ADType< A, Nvar, order, Var >
, ADCst< C > > > 
operator<= (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryLessOrEqual
< ADExpr< E >, ADCst< C > > > 
operator<= (const ADExpr< E > &e, C t)
 
template<class E , class C >
ADExpr< ADBinaryLessOrEqual
< ADCst< C >, ADExpr< E > > > 
operator<= (C t, const ADExpr< E > &e)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryLessOrEqual
< ADType< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator<= (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E1 , class E2 >
ADExpr< ADBinaryEqual< ADExpr
< E1 >, ADExpr< E2 > > > 
operator== (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryEqual< ADExpr
< E >, ADType< typename
E::value_type, Nvar, order,
Var > > > 
operator== (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryEqual< ADType
< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator== (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryEqual< ADType
< typename E::value_type, Nvar,
order, Var >, ADExpr< E > > > 
operator== (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryEqual< ADCst
< C >, ADType< A, Nvar, order,
Var > > > 
operator== (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryEqual< ADType
< A, Nvar, order, Var >, ADCst
< C > > > 
operator== (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryEqual< ADCst
< C >, ADExpr< E > > > 
operator== (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryEqual< ADExpr
< E >, ADCst< C > > > 
operator== (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryGreater
< ADExpr< E1 >, ADExpr< E2 > > > 
operator> (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryGreater
< ADExpr< E >, ADType
< typename E::value_type, Nvar,
order, Var > > > 
operator> (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryGreater
< ADType< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator> (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryGreater
< ADType< typename
E::value_type, Nvar, order,
Var >, ADExpr< E > > > 
operator> (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryGreater< ADCst
< C >, ADType< A, Nvar, order,
Var > > > 
operator> (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryGreater
< ADType< A, Nvar, order, Var >
, ADCst< C > > > 
operator> (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryGreater< ADCst
< C >, ADExpr< E > > > 
operator> (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryGreater
< ADExpr< E >, ADCst< C > > > 
operator> (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryGreaterOrEqual
< ADExpr< E1 >, ADExpr< E2 > > > 
operator>= (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryGreaterOrEqual
< ADExpr< E >, ADType
< typename E::value_type, Nvar,
order, Var > > > 
operator>= (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryGreaterOrEqual
< ADType< A, Nvar, order, Var1 >
, ADType< A, Nvar, order, Var2 > > > 
operator>= (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryGreaterOrEqual
< ADType< typename
E::value_type, Nvar, order,
Var >, ADExpr< E > > > 
operator>= (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryGreaterOrEqual
< ADCst< C >, ADType< A, Nvar,
order, Var > > > 
operator>= (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryGreaterOrEqual
< ADType< A, Nvar, order, Var >
, ADCst< C > > > 
operator>= (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryGreaterOrEqual
< ADCst< C >, ADExpr< E > > > 
operator>= (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryGreaterOrEqual
< ADExpr< E >, ADCst< C > > > 
operator>= (const ADExpr< E > &e, C t)
 
template<class E1 , class E2 >
ADExpr< ADBinaryPow< ADExpr
< E1 >, ADExpr< E2 > > > 
operator^ (const ADExpr< E1 > &v, const ADExpr< E2 > &w)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryPow< ADExpr< E >
, ADType< typename
E::value_type, Nvar, order,
Var > > > 
operator^ (const ADExpr< E > &e, const ADType< typename E::value_type, Nvar, order, Var > &v)
 
template<typename A , int Nvar, int order, int Var1, int Var2>
ADExpr< ADBinaryPow< ADType< A,
Nvar, order, Var1 >, ADType< A,
Nvar, order, Var2 > > > 
operator^ (const ADType< A, Nvar, order, Var1 > &e1, const ADType< A, Nvar, order, Var2 > &e2)
 
template<class E , int Nvar, int order, int Var>
ADExpr< ADBinaryPow< ADType
< typename E::value_type, Nvar,
order, Var >, ADExpr< E > > > 
operator^ (const ADType< typename E::value_type, Nvar, order, Var > &v, const ADExpr< E > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryPow< ADCst< C >
, ADType< A, Nvar, order, Var > > > 
operator^ (C a, const ADType< A, Nvar, order, Var > &e)
 
template<typename A , typename C , int Nvar, int order, int Var>
ADExpr< ADBinaryPow< ADType< A,
Nvar, order, Var >, ADCst< C > > > 
operator^ (const ADType< A, Nvar, order, Var > &e, C a)
 
template<class E , class C >
ADExpr< ADBinaryPow< ADCst< C >
, ADExpr< E > > > 
operator^ (C t, const ADExpr< E > &e)
 
template<class E , class C >
ADExpr< ADBinaryPow< ADExpr< E >
, ADCst< C > > > 
operator^ (const ADExpr< E > &e, C t)
 

Detailed Description


Generated on Sun Dec 22 2013 13:11:15 for Feel++ by doxygen 1.8.5