Enable use of AD<Base> where Base is std::complex<double>

Enable use of AD<Base> where Base is std::complex<double>
Example
The file ComplexPoly.cpp contains an example use of std::complex<double> type for a CppAD Base type. It returns true if it succeeds and false otherwise.

See Also
The file not_complex_ad.cpp contains an example using complex arithmetic where the function is not complex differentiable.

Include Order
This file is included before <cppad/cppad.hpp> so it is necessary to define the error handler in addition to including base_require.hpp

 
# include <limits>
# include <complex>
# include <cppad/base_require.hpp>
# include <cppad/local/cppad_assert.hpp>

CondExpOp
The type std::complex<double> does not supports the <, <=, ==, >=, and > operators; see not ordered . Hence its CondExpOp function is defined by

 
namespace CppAD {
	inline std::complex<double> CondExpOp(
		enum CppAD::CompareOp      cop        ,
		const std::complex<double> &left      ,
		const std::complex<double> &right     ,
		const std::complex<double> &trueCase  ,
		const std::complex<double> &falseCase )
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			"std::complex<float> CondExpOp(...)",
			"Error: cannot use CondExp with a complex type"
		);
		return std::complex<double>(0);
	}
}

CondExpRel
The CPPAD_COND_EXP_REL macro invocation

 
namespace CppAD {
	CPPAD_COND_EXP_REL( std::complex<double> )
}

used CondExpOp above to define CondExpRel for std::complex<double> arguments and Rel equal to Lt, Le, Eq, Ge, and Gt.

EqualOpSeq
Complex numbers do not carry operation sequence information. Thus they are equal in this sense if and only if there values are equal.

 
namespace CppAD {
	inline bool EqualOpSeq(
		const std::complex<double> &x , 
		const std::complex<double> &y )
	{	return x == y; 
	}
}

Identical
Complex numbers do not carry operation sequence information. Thus they are all parameters so the identical functions just check values.

 
namespace CppAD {
	inline bool IdenticalPar(const std::complex<double> &x)
	{	return true; }
	inline bool IdenticalZero(const std::complex<double> &x)
	{	return (x == std::complex<double>(0., 0.) ); }
	inline bool IdenticalOne(const std::complex<double> &x)
	{	return (x == std::complex<double>(1., 0.) ); }
	inline bool IdenticalEqualPar(
		const std::complex<double> &x, const std::complex<double> &y)
	{	return (x == y); }
}

Ordered
Complex types do not support comparison operators,

 
# undef  CPPAD_USER_MACRO
# define CPPAD_USER_MACRO(Fun)                                     \
inline bool Fun(const std::complex<double>& x)                     \
{      CppAD::ErrorHandler::Call(                                  \
               true     , __LINE__ , __FILE__ ,                    \
               #Fun"(x)",                                          \
               "Error: cannot use " #Fun " with x complex<double> " \
       );                                                          \
       return false;                                               \
}
namespace CppAD {
	CPPAD_USER_MACRO(LessThanZero)
	CPPAD_USER_MACRO(LessThanOrZero)
	CPPAD_USER_MACRO(GreaterThanOrZero)
	CPPAD_USER_MACRO(GreaterThanZero)
	inline bool abs_geq(
		const std::complex<double>& x , 
		const std::complex<double>& y )
	{	return std::abs(x) >= std::abs(y); }
}

Integer
The implementation of this function must agree with the CppAD user specifications for complex arguments to the Integer function:

 
namespace CppAD {
	inline int Integer(const std::complex<double> &x)
	{	return static_cast<int>( x.real() ); }
}

epsilon
The standard double complex machine epsilon in a double, hence we must convert it to a complex to meet the prototype for the CppAD machine epsilon function.

 
namespace CppAD {
	template <>
	inline std::complex<double> epsilon< std::complex<double> >(void)
	{	double eps = std::numeric_limits<double>::epsilon();
		return std::complex<double>(eps, 0.);
	}
}

isnan
The gcc 4.1.1 complier defines the function



     int std::complex<double>::isnan( std::complex<double> z )

(which is not specified in the C++ 1998 standard ISO/IEC 14882). This causes an ambiguity between the function above and the CppAD isnan template function. We avoid this ambiguity by defining a non-template version of this function in the CppAD namespace.

 
namespace CppAD {
	inline bool isnan(const std::complex<double>& z)
	{	CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL;	
		static const double nan = std::numeric_limits<double>::quiet_NaN();
		return (z != z) | (z.real() == nan) | (z.imag() == nan);
	}
}

Valid Unary Math
The following macro invocations define the standard unary math functions that are valid with complex arguments and are required to use AD< std::complex<double> >.

 
namespace CppAD {
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cos)
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cosh)
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, exp)
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, log)
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sin)
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sinh)
	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sqrt)
}

Invalid Unary Math
The following macro definition and invocations define the standard unary math functions that are invalid with complex arguments and are required to use AD< std::complex<double> >.

 
# undef  CPPAD_USER_MACRO
# define CPPAD_USER_MACRO(Fun)                                     \
inline std::complex<double> Fun(const std::complex<double>& x)     \
{      CppAD::ErrorHandler::Call(                                  \
               true     , __LINE__ , __FILE__ ,                    \
               #Fun"(x)",                                          \
               "Error: cannot use " #Fun " with x complex<double> " \
       );                                                          \
       return std::complex<double>(0);                             \
}
namespace CppAD {
	CPPAD_USER_MACRO(abs)
	CPPAD_USER_MACRO(acos)
	CPPAD_USER_MACRO(asin)
	CPPAD_USER_MACRO(atan)
	CPPAD_USER_MACRO(sign)
}

pow
The following defines a CppAD::pow function that is required to use AD< std::complex<double> >:

 
namespace CppAD {
	inline std::complex<double> pow(
		const std::complex<double> &x , 
		const std::complex<double> &y )
	{	return std::pow(x, y); }
}

Input File: cppad/local/base_complex.hpp