[CppAD] Own Data Type

[Dominik Skanda]

Hello all,

I try to implement my own numeric base type for use with cppAD, i.e.
with QD Library a numeric type with 63 digits
( http://crd.lbl.gov/~dhbailey/mpdist/ ). For that I try to extend the
example ( http://www.coin-or.org/CppAD/Doc/numerictype.cpp.xml ). 
But somehow it's not working correctly. Has someone experience with a
similar case?

Specially I want that following works:

vector< CppAD::AD<MyType> > X(1);
vector< CppAD::AD<MyType> > Y(1);


CppAD::ADFun<MyType> F;
		
X[0]=6.2785676;

CppAD::Independent(X);
		

Y[0]=X[0]-234.6665675;
		
F.Dependent(X, Y);


I have no glue what happens with the numbers 6.2785676 and 234.6665675
for instance.

The definition of MyType looks by now:


	class MyType {
	private:
		qd_real d;
	public:
		// constructor from void 
		MyType(void) : d(0.)
		{ }
		// constructor from an int 
		MyType(int d_) : d(d_)
		{ }
		
		// constructor from an qd_real 
		MyType(qd_real d_) : d(d_)
		{ }
		
		// constructor from an MyType
		MyType(const MyType &d_) : d(d_.d)
		{ }
				
		// assignment operator
		
		MyType& operator = (const MyType &x)
		{
			if (this != &x) {	
			d = x.returnValue(); 
			}	
			return *this;
		}
		
		MyType operator = (const double &x)
		{
			d = x; 	
			return *this;
		}
		
		MyType operator = (const qd_real  &x)
		{
			d = x; 	
			return *this;
		}
						
		// member function that converts to double
		double Double(void) const
		{	return to_double(d); }
		qd_real returnValue(void) const
		{   return d;}
		
		// unary plus
		MyType operator + (void) const
		{	MyType x;
			x.d =  d;
			return x; 
		}
		// unary plus
		MyType operator - (void) const
		{	MyType x;
			x.d = - d;
			return x; 
		}
		// binary addition
		MyType operator + (const MyType &x) const
		{	MyType y;
			y.d = d + x.d ;
			return y; 
		}
		// binary subtraction
		MyType operator - (const MyType &x) const
		{	MyType y;
			y.d = d - x.d ;
			return y; 
		}
		MyType operator - (const double &x) const
		{	MyType y;
			y.d = d - x ;
			return y; 
		}
		
		// binary multiplication
		MyType operator * (const MyType &x) const
		{	MyType y;
			y.d = d * x.d ;
			return y; 
		}
		// binary division
		MyType operator / (const MyType &x) const
		{	MyType y;
			y.d = d / x.d ;
			return y; 
		}
		// computed assignment addition
		void operator += (const MyType &x)
		{	d += x.d; }
		
		void operator += (const double &x)
		{	d += x; }
		// computed assignment subtraction
		void operator -= (const MyType &x)
		{	d -= x.d; }
		
		void operator -= (const double &x)
		{	d -= x; }
		
		
		
		// computed assignment multiplication
		void operator *= (const MyType &x)
		{	d *= x.d; }
		// computed assignment division
		void operator /= (const MyType &x)
		{	d /= x.d; }
		
		bool operator == (const MyType &x) const
		{return d==x.d;}
		
		bool operator != (const MyType &x) const
		{return d!=x.d;}
		
		
		friend std::ostream& operator<<(std::ostream& out, const MyType& f)
			{
				out << f.d;
				
				return out;
			}		
	};


namespace CppAD {
	inline bool EqualOpSeq(
		const MyType &x , 
		const MyType &y )
	{	
		return x == y; 
	}



	inline bool IdenticalPar(const MyType &x)
	{	return true; }
	inline bool IdenticalZero(const MyType &x)
	{	return (x.returnValue() == 0.0 ); }
	inline bool IdenticalOne(const MyType &x)
	{	return (x.returnValue() == 1.0 ); }
	inline bool IdenticalEqualPar(const MyType &x,const MyType &y)
	{	return (x==y); }



	inline MyType cos(const MyType &x)   
	{	return MyType(cos(x.returnValue())); }
	
	inline MyType cosh(const MyType &x)   
	{	return MyType(cosh(x.returnValue())); }
	
	inline MyType exp(const MyType &x)   
	{	return MyType(exp(x.returnValue())); }
	
	inline MyType log(const MyType &x)   
	{	return MyType(log(x.returnValue())); }
	
	inline MyType pow(const MyType &x, const MyType &y)   
	{	return MyType(pow(x.returnValue(),y.returnValue())); }
	
	inline MyType sin(const MyType &x)   
	{	return MyType(sin(x.returnValue())); }
	
	inline MyType sinh(const MyType &x)   
	{	return MyType(sinh(x.returnValue())); }
	
	inline MyType sqrt(const MyType &x)   
	{	return MyType(sqrt(x.returnValue())); }
	
	inline MyType atan(const MyType &x)   
	{	return MyType(atan(x.returnValue())); }
	
	inline MyType acos(const MyType &x)   
	{	return MyType(acos(x.returnValue())); }
	
	inline MyType asin(const MyType &x)   
	{	return MyType(asin(x.returnValue())); }


	inline MyType CondExpOp(
		enum CppAD::CompareOp      cop        ,
		const MyType &left      ,
		const MyType &right     ,
		const MyType &trueCase  ,
		const MyType &falseCase )
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			"MyType CondExpOp(...)",
			"Error: cannot use CondExp with a MyType by now"
		);
		return MyType(0);
	}

	inline bool GreaterThanZero(const MyType &x)
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			"GreaterThanZero(x)",
			"Error: cannot use GreaterThanZero with MyType"
		);
		return false;
	}
	inline bool GreaterThanOrZero(const MyType &x)
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			"GreaterThanZero(x)",
			"Error: cannot use GreaterThanZero with MyType"
		);
		return false;
	}
	inline bool LessThanZero(const MyType &x)
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			"LessThanZero(x)",
			"Error: cannot use LessThanZero with MyType"
		);
		return false;
	}
	inline bool LessThanOrZero(const MyType &x)
	{	CppAD::ErrorHandler::Call(
			true     , __LINE__ , __FILE__ ,
			"LessThanZero(x)",
			"Error: cannot use LessThanZero with MyType"
		);
		return false;
	}

	inline int Integer(const MyType &x)
	{	return static_cast<int>( x.Double() ); }
}










Many thanks in advance

Dominik