[CppAD] Own Data Type
Dominik Skanda
Dominik.Skanda at biologie.uni-freiburg.de
Tue Mar 1 05:40:22 EST 2011
Hello,
I have added now
MyType(size_t d_) : d((int)d_)
{ }
// constructor from an double
MyType(double d_) : d(d_)
{ }
and now its working!
Thanks Stefan your hint was the right way...
Dominik
Am Montag, den 28.02.2011, 23:58 +0100 schrieb Stefan Vigerske:
> Hi,
>
> maybe remove the constructor for int then, or add one for size_t.
> Converting int's to double's should be better than loosing digits when
> converting from double to int.
>
> Stefan
>
> Am 28.02.2011 23:56, schrieb Dominik Skanda:
> > Hello,
> >
> > yes I tried to add
> >
> > // constructor from an double
> > MyType(double d_) : d(d_)
> > {}
> >
> >
> > but then the compiler complained about something with
> > ambigious overload t_size ...
> >
> > I'm not at work so I can't give the exact error message.
> > Tomorrow I will post it.
> >
> > regards
> >
> > Dominik
> >
> >
> >
> >
> >
> >
> > On Mon, 28 Feb 2011 23:50:59 +0100
> > Stefan Vigerske<stefan at math.hu-berlin.de> wrote:
> >> Hi,
> >>
> >>> Hello thanks for help,
> >>>
> >>> I don't get a compile or runtime error. The thing is
> >> that
> >>> the calculations are not performed correctly. For
> >> example
> >>> in the instance below instead of using -234.6665675 the
> >>> code only uses -234. I have not really a glue which
> >> methods
> >>> I have to implement in the MyType class, so that CppAD
> >> uses
> >>> it correctly and I can use the new type like the type
> >>> double for instance. The second thing I wonder, how the
> >>> program recognizes if I use a expression like
> >>>
> >>> Y[0]=X[0]-234.123456789123456789123456789123456789;
> >>>
> >>> does the compiler first convert it to a double. Does it
> >>> shrink the significant digits? I only have adapted the
> >>> example found in the documentation and modified it till
> >> it
> >>> compiles, but somehow I miss a important part!
> >>
> >> I would expect that it converts 234.12345... to your base
> >> type and then calls the MyType::operator-(MyType&) method
> >> that you overloaded.
> >> In the first part, something may go wrong because you do
> >> not seem to have a constructor for a double argument.
> >> Maybe it converts it to int then and calls the
> >> constructor for int.
> >> There should be a compiler warning, though, at least if
> >> enough warnings are enabled.
> >>
> >> Some printfs or help with gdb should help to see clearly
> >> what is actually executed. :-)
> >>
> >> Stefan
> >>
> >>>
> >>> regards
> >>>
> >>> Dominik
> >>>
> >>>
> >>>
> >>> On Mon, 28 Feb 2011 23:00:33 +0100
> >>> Stefan Vigerske<stefan at math.hu-berlin.de> wrote:
> >>>> Hi,
> >>>>
> >>>> CppAD work's for me with my own base type.
> >>>> What kind of error you get?
> >>>>
> >>>> Stefan
> >>>>
> >>>> Am 28.02.2011 18:23, schrieb 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
> >>>>>
> >>>>>
> >>>>> _______________________________________________
> >>>>> CppAD mailing list
> >>>>> CppAD at list.coin-or.org
> >>>>> http://list.coin-or.org/mailman/listinfo/cppad
> >>>>>
> >>>>
> >>>> _______________________________________________
> >>>> CppAD mailing list
> >>>> CppAD at list.coin-or.org
> >>>> http://list.coin-or.org/mailman/listinfo/cppad
> >>>
> >>
> >
>
More information about the CppAD
mailing list