24 template <
int D,
typename SCAL =
double>
54 for (
int i = 0; i < D; i++)
62 for (
int i = 0; i < D; i++)
77 for (
int i = 0; i < D; i++)
85 INLINE SCAL
Value()
const throw() {
return val; }
88 INLINE SCAL
DValue (
int i)
const throw() {
return dval[i]; }
91 INLINE
void StoreGradient (SCAL * p)
const
93 for (
int i = 0; i < D; i++)
97 INLINE
void LoadGradient (
const SCAL * p)
99 for (
int i = 0; i < D; i++)
104 INLINE SCAL &
Value() throw() {
return val; }
107 INLINE SCAL &
DValue (
int i)
throw() {
return dval[i]; }
114 template<
int D,
typename SCAL>
117 ost << x.
Value() <<
", D = ";
118 for (
int i = 0; i < D; i++)
119 ost << x.
DValue(i) <<
" ";
124 template<
int D,
typename SCAL>
128 res.
Value () = x.Value()+y.Value();
130 for (
int i = 0; i < D; i++)
131 res.
DValue(i) = x.DValue(i) + y.DValue(i);
137 template<
int D,
typename SCAL>
141 res.
Value() = x.Value()-y.Value();
143 for (
int i = 0; i < D; i++)
144 res.
DValue(i) = x.DValue(i) - y.DValue(i);
149 template<
int D,
typename SCAL,
typename SCAL2,
150 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
154 res.
Value() = x+y.Value();
155 for (
int i = 0; i < D; i++)
156 res.
DValue(i) = y.DValue(i);
161 template<
int D,
typename SCAL,
typename SCAL2,
162 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
166 res.
Value() = x+y.Value();
167 for (
int i = 0; i < D; i++)
168 res.
DValue(i) = y.DValue(i);
174 template<
int D,
typename SCAL>
178 res.
Value() = -x.Value();
179 for (
int i = 0; i < D; i++)
180 res.
DValue(i) = -x.DValue(i);
185 template<
int D,
typename SCAL,
typename SCAL2,
186 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
190 res.
Value() = x.Value()-y;
191 for (
int i = 0; i < D; i++)
192 res.
DValue(i) = x.DValue(i);
197 template<
int D,
typename SCAL,
typename SCAL2,
198 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
199 INLINE AutoDiffVec<D,SCAL> operator- (SCAL2 x,
const AutoDiffVec<D,SCAL> & y)
throw()
201 AutoDiffVec<D,SCAL> res;
202 res.
Value() = x-y.Value();
203 for (
int i = 0; i < D; i++)
204 res.DValue(i) = -y.DValue(i);
210 template<
int D,
typename SCAL,
typename SCAL2,
211 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
215 res.
Value() = x*y.Value();
216 for (
int i = 0; i < D; i++)
217 res.
DValue(i) = x*y.DValue(i);
222 template<
int D,
typename SCAL,
typename SCAL2,
223 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
228 res.
Value() = x*y.Value();
229 for (
int i = 0; i < D; i++)
230 res.
DValue(i) = x*y.DValue(i);
235 template<
int D,
typename SCAL>
243 for (
int i = 0; i < D; i++)
244 res.
DValue(i) = hx*y.DValue(i) + hy*x.DValue(i);
250 template<
int D,
typename SCAL>
257 for (
int i = 0; i < D; i++)
258 res.
DValue(i) = hx*x.DValue(i);
263 template<
int D,
typename SCAL>
267 for (
int i = 0; i < D; i++)
274 template<
int D,
typename SCAL>
281 template<
int D,
typename SCAL,
typename SCAL2,
282 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
289 template<
int D,
typename SCAL,
typename SCAL2,
290 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
299 template <
int D,
typename SCAL,
typename SCAL2>
300 INLINE AutoDiffVec<D,SCAL> & operator+= (AutoDiffVec<D,SCAL> & x, SCAL2 y)
throw()
308 template <
int D,
typename SCAL>
309 INLINE AutoDiffVec<D,SCAL> & operator+= (AutoDiffVec<D,SCAL> & x, AutoDiffVec<D,SCAL> y)
311 x.Value() += y.Value();
312 for (
int i = 0; i < D; i++)
313 x.DValue(i) += y.DValue(i);
318 template <
int D,
typename SCAL>
319 INLINE AutoDiffVec<D,SCAL> & operator-= (AutoDiffVec<D,SCAL> & x, AutoDiffVec<D,SCAL> y)
321 x.Value() -= y.Value();
322 for (
int i = 0; i < D; i++)
323 x.DValue(i) -= y.DValue(i);
328 template <
int D,
typename SCAL,
typename SCAL2>
329 INLINE AutoDiffVec<D,SCAL> & operator-= (AutoDiffVec<D,SCAL> & x, SCAL2 y)
336 template <
int D,
typename SCAL>
337 INLINE AutoDiffVec<D,SCAL> & operator*= (AutoDiffVec<D,SCAL> & x, AutoDiffVec<D,SCAL> y)
339 for (
int i = 0; i < D; i++)
340 x.DValue(i) = x.DValue(i)*y.Value() + x.Value() * y.DValue(i);
341 x.Value() *= y.Value();
346 template <
int D,
typename SCAL,
typename SCAL2>
347 INLINE AutoDiffVec<D,SCAL> & operator*= (AutoDiffVec<D,SCAL> & x, SCAL2 y)
350 for (
int i = 0; i < D; i++)
356 template <
int D,
typename SCAL>
357 INLINE AutoDiffVec<D,SCAL> & operator/= (AutoDiffVec<D,SCAL> & x, SCAL y)
361 for (
int i = 0; i < D; i++)
370 template <
int D,
typename SCAL>
371 INLINE
bool operator== (AutoDiffVec<D,SCAL> x, SCAL val2)
373 return x.Value() == val2;
377 template <
int D,
typename SCAL>
378 INLINE
bool operator!= (AutoDiffVec<D,SCAL> x, SCAL val2)
throw()
380 return x.Value() != val2;
384 template <
int D,
typename SCAL>
385 INLINE
bool operator< (AutoDiffVec<D,SCAL> x, SCAL val2)
throw()
387 return x.Value() < val2;
391 template <
int D,
typename SCAL>
392 INLINE
bool operator> (AutoDiffVec<D,SCAL> x, SCAL val2)
throw()
394 return x.Value() > val2;
400 template<
int D,
typename SCAL>
401 INLINE AutoDiffVec<D,SCAL> fabs (
const AutoDiffVec<D,SCAL> & x)
403 double abs = fabs (x.Value());
404 AutoDiffVec<D,SCAL> res( abs );
406 for (
int i = 0; i < D; i++)
407 res.DValue(i) = x.Value()*x.DValue(i) / abs;
409 for (
int i = 0; i < D; i++)
415 template<
int D,
typename SCAL>
416 INLINE AutoDiffVec<D,SCAL> sqrt (
const AutoDiffVec<D,SCAL> & x)
418 AutoDiffVec<D,SCAL> res;
419 res.Value() = sqrt(x.Value());
420 for (
int j = 0; j < D; j++)
421 res.DValue(j) = 0.5 / res.Value() * x.DValue(j);
426 template <
int D,
typename SCAL>
427 AutoDiffVec<D,SCAL> log (AutoDiffVec<D,SCAL> x)
429 AutoDiffVec<D,SCAL> res;
430 res.Value() = log(x.Value());
431 for (
int k = 0; k < D; k++)
432 res.DValue(k) = x.DValue(k) / x.Value();
437 template <
int D,
typename SCAL>
438 INLINE AutoDiffVec<D,SCAL> exp (AutoDiffVec<D,SCAL> x)
440 AutoDiffVec<D,SCAL> res;
441 res.Value() = exp(x.Value());
442 for (
int k = 0; k < D; k++)
443 res.DValue(k) = x.DValue(k) * res.Value();
448 template <
int D,
typename SCAL>
449 INLINE AutoDiffVec<D,SCAL> pow (AutoDiffVec<D,SCAL> x, AutoDiffVec<D,SCAL> y )
451 return exp(log(x)*y);
468 template <
int D,
typename SCAL>
469 INLINE AutoDiffVec<D,SCAL> sin (AutoDiffVec<D,SCAL> x)
471 return sin(AutoDiffRec<D,SCAL>(x));
487 template <
int D,
typename SCAL>
488 INLINE AutoDiffVec<D,SCAL> cos (AutoDiffVec<D,SCAL> x)
490 return cos(AutoDiffRec<D,SCAL>(x));
494 template <
int D,
typename SCAL>
495 INLINE AutoDiffVec<D,SCAL> tan (AutoDiffVec<D,SCAL> x)
496 {
return sin(x) / cos(x); }
499 template <
int D,
typename SCAL>
500 INLINE AutoDiffVec<D,SCAL> sinh (AutoDiffVec<D,SCAL> x)
502 AutoDiffVec<D,SCAL> res;
503 res.Value() = sinh(x.Value());
504 SCAL ch = cosh(x.Value());
505 for (
int k = 0; k < D; k++)
506 res.DValue(k) = x.DValue(k) * ch;
511 template <
int D,
typename SCAL>
512 INLINE AutoDiffVec<D,SCAL> cosh (AutoDiffVec<D,SCAL> x)
514 AutoDiffVec<D,SCAL> res;
515 res.Value() = cosh(x.Value());
516 SCAL sh = sinh(x.Value());
517 for (
int k = 0; k < D; k++)
518 res.DValue(k) = x.DValue(k) * sh;
523 template<
int D,
typename SCAL>
524 INLINE AutoDiffVec<D,SCAL> floor (
const AutoDiffVec<D,SCAL> & x)
526 AutoDiffVec<D,SCAL> res;
527 res.Value() = floor(x.Value());
528 for (
int j = 0; j < D; j++)
534 template<
int D,
typename SCAL>
535 INLINE AutoDiffVec<D,SCAL> ceil (
const AutoDiffVec<D,SCAL> & x)
537 AutoDiffVec<D,SCAL> res;
538 res.Value() = ceil(x.Value());
539 for (
int j = 0; j < D; j++)
558 template <
int D,
typename SCAL>
559 AutoDiffVec<D,SCAL> atan (AutoDiffVec<D,SCAL> x)
561 return atan (AutoDiffRec<D,SCAL> (x));
565 template <
int D,
typename SCAL>
566 INLINE AutoDiffVec<D,SCAL> atan2 (AutoDiffVec<D,SCAL> x, AutoDiffVec<D,SCAL> y)
568 AutoDiffVec<D,SCAL> res;
569 SCAL a = atan2(x.Value(), y.Value());
571 for (
int k = 0; k < D; k++)
572 res.DValue(k) = (x.Value()*y.DValue(k)-y.Value()*x.DValue(k))/(y.Value()*y.Value()+x.Value()*x.Value());
578 template <
int D,
typename SCAL>
579 INLINE AutoDiffVec<D,SCAL> acos (AutoDiffVec<D,SCAL> x)
581 AutoDiffVec<D,SCAL> res;
582 SCAL a = acos(x.Value());
584 SCAL da = -1 / sqrt(1-x.Value()*x.Value());
585 for (
int k = 0; k < D; k++)
586 res.DValue(k) = x.DValue(k)*da;
592 template <
int D,
typename SCAL>
593 INLINE AutoDiffVec<D,SCAL> asin (AutoDiffVec<D,SCAL> x)
595 AutoDiffVec<D,SCAL> res;
596 SCAL a = asin(x.Value());
598 SCAL da = 1 / sqrt(1-x.Value()*x.Value());
599 for (
int k = 0; k < D; k++)
600 res.DValue(k) = x.DValue(k)*da;
607 template <
int D,
typename SCAL,
typename TB,
typename TC>
608 auto IfPos (AutoDiffVec<D,SCAL> a, TB b, TC c)
610 return IfPos (a.Value(), b, c);
613 template <
int D,
typename SCAL>
614 INLINE AutoDiffVec<D,SCAL> IfPos (SCAL a, AutoDiffVec<D,SCAL> b, AutoDiffVec<D,SCAL> c)
616 AutoDiffVec<D,SCAL> res;
617 res.Value() = IfPos (a, b.Value(), c.Value());
618 for (
int j = 0; j < D; j++)
619 res.DValue(j) = IfPos (a, b.DValue(j), c.DValue(j));
623 template <
int D,
typename SCAL,
typename TC>
624 INLINE AutoDiffVec<D,SCAL> IfPos (SCAL a, AutoDiffVec<D,SCAL> b, TC c)
626 return IfPos (a, b, AutoDiffVec<D,SCAL> (c));
633 template <
int D,
typename SCAL>
636 AutoDiffRec<D-1, SCAL> rec;
640 INLINE AutoDiffRec () =
default;
641 INLINE AutoDiffRec (
const AutoDiffRec &) =
default;
642 INLINE AutoDiffRec (AutoDiffRec<D-1,SCAL> _rec, SCAL _last) : rec(_rec), last(_last) { ; }
643 INLINE AutoDiffRec & operator= (
const AutoDiffRec &) =
default;
645 INLINE AutoDiffRec (SCAL aval) : rec(aval), last(0.0) { ; }
646 INLINE AutoDiffRec (SCAL aval,
int diffindex) : rec(aval, diffindex), last((diffindex==D-1) ? 1.0 : 0.0) { ; }
647 INLINE AutoDiffRec (SCAL aval,
const SCAL * grad)
648 : rec(aval, grad), last(grad[D-1]) { }
650 INLINE AutoDiffRec (
const AutoDiffVec<D,SCAL> & ad)
652 Value() = ad.Value();
653 for (
int i = 0; i < D; i++)
654 DValue(i) = ad.DValue(i);
657 INLINE AutoDiffRec & operator= (SCAL aval) { rec = aval; last = 0.0;
return *
this; }
658 INLINE SCAL Value()
const {
return rec.Value(); }
659 INLINE SCAL DValue(
int i)
const {
return (i == D-1) ? last : rec.DValue(i); }
660 INLINE SCAL & Value() {
return rec.Value(); }
661 INLINE SCAL & DValue(
int i) {
return (i == D-1) ? last : rec.DValue(i); }
662 INLINE
auto Rec()
const {
return rec; }
663 INLINE
auto Last()
const {
return last; }
664 INLINE
auto & Rec() {
return rec; }
665 INLINE
auto & Last() {
return last; }
666 INLINE
operator AutoDiffVec<D,SCAL> ()
const
668 AutoDiffVec<D,SCAL> res(Value());
669 for (
int i = 0; i < D; i++)
670 res.DValue(i) = DValue(i);
675 template<
int D,
typename SCAL>
676 ostream &
operator<< (ostream & ost, AutoDiffRec<D,SCAL> ad)
678 return ost << AutoDiffVec<D,SCAL> (ad);
681 template <
typename SCAL>
689 INLINE
AutoDiffRec (SCAL _val, SCAL ) : val(_val) { ; }
694 INLINE
AutoDiffRec & operator= (SCAL aval) { val = aval;
return *
this; }
696 INLINE SCAL Value()
const {
return val; }
697 INLINE SCAL DValue(
int )
const {
return SCAL(0); }
698 INLINE SCAL & Value() {
return val; }
700 INLINE
auto Rec()
const {
return val; }
701 INLINE
auto Last()
const {
return SCAL(0); }
702 INLINE
auto & Rec() {
return val; }
703 INLINE
auto & Last() {
return val; }
708 template <
typename SCAL>
716 INLINE
AutoDiffRec (SCAL _val) : val(_val), last(0.0) { ; }
717 INLINE
AutoDiffRec (SCAL _val, SCAL _last) : val(_val), last(_last) { ; }
718 INLINE
AutoDiffRec (SCAL aval,
int diffindex) : val(aval), last((diffindex==0) ? 1.0 : 0.0) { ; }
720 : val(aval), last(grad[0]) { }
724 Value() = ad.
Value();
729 INLINE
AutoDiffRec & operator= (SCAL aval) { val = aval; last = 0.0;
return *
this; }
731 INLINE SCAL Value()
const {
return val; }
732 INLINE SCAL DValue(
int )
const {
return last; }
733 INLINE SCAL & Value() {
return val; }
734 INLINE SCAL & DValue(
int ) {
return last; }
735 INLINE
auto Rec()
const {
return val; }
736 INLINE
auto Last()
const {
return last; }
737 INLINE
auto & Rec() {
return val; }
738 INLINE
auto & Last() {
return last; }
743 res.
DValue(0) = DValue(0);
748 template <
int D,
typename SCAL,
typename SCAL2,
749 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
755 template <
int D,
typename SCAL,
typename SCAL2,
756 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
757 INLINE AutoDiffRec<D,SCAL> operator+ (AutoDiffRec<D,SCAL> a, SCAL2 b)
759 return AutoDiffRec<D,SCAL> (a.Rec()+b, a.Last());
762 template <
int D,
typename SCAL>
763 INLINE AutoDiffRec<D,SCAL> operator+ (AutoDiffRec<D,SCAL> a, AutoDiffRec<D,SCAL> b)
765 return AutoDiffRec<D,SCAL> (a.Rec()+b.Rec(), a.Last()+b.Last());
768 template <
int D,
typename SCAL,
typename SCAL2,
769 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
770 INLINE AutoDiffRec<D,SCAL> operator- (SCAL2 b, AutoDiffRec<D,SCAL> a)
772 return AutoDiffRec<D,SCAL> (b-a.Rec(), -a.Last());
775 template <
int D,
typename SCAL,
typename SCAL2,
776 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
777 INLINE AutoDiffRec<D,SCAL> operator- (AutoDiffRec<D,SCAL> a, SCAL2 b)
779 return AutoDiffRec<D,SCAL> (a.Rec()-b, a.Last());
782 template <
int D,
typename SCAL>
783 INLINE AutoDiffRec<D,SCAL> operator- (AutoDiffRec<D,SCAL> a, AutoDiffRec<D,SCAL> b)
785 return AutoDiffRec<D,SCAL> (a.Rec()-b.Rec(), a.Last()-b.Last());
789 template<
int D,
typename SCAL>
795 template <
int D,
typename SCAL>
796 INLINE AutoDiffRec<D,SCAL> operator* (AutoDiffRec<D,SCAL> a, AutoDiffRec<D,SCAL> b)
798 return AutoDiffRec<D,SCAL> (a.Rec()*b.Rec(), a.Value()*b.Last()+b.Value()*a.Last());
801 template <
int D,
typename SCAL,
typename SCAL1,
802 typename std::enable_if<std::is_convertible<SCAL1,SCAL>::value,
int>::type = 0>
803 INLINE AutoDiffRec<D,SCAL> operator* (AutoDiffRec<D,SCAL> b, SCAL1 a)
805 return AutoDiffRec<D,SCAL> (a*b.Rec(), a*b.Last());
808 template <
int D,
typename SCAL,
typename SCAL1,
809 typename std::enable_if<std::is_convertible<SCAL1,SCAL>::value,
int>::type = 0>
810 INLINE AutoDiffRec<D,SCAL> operator* (SCAL1 a, AutoDiffRec<D,SCAL> b)
812 return AutoDiffRec<D,SCAL> (a*b.Rec(), a*b.Last());
815 template <
int D,
typename SCAL>
816 INLINE AutoDiffRec<D,SCAL> & operator+= (AutoDiffRec<D,SCAL> & a, AutoDiffRec<D,SCAL> b)
819 a.Last() += b.Last();
823 template <
int D,
typename SCAL>
824 INLINE AutoDiffRec<D,SCAL> & operator-= (AutoDiffRec<D,SCAL> & a,
double b)
830 template <
int D,
typename SCAL>
831 INLINE AutoDiffRec<D,SCAL> & operator-= (AutoDiffRec<D,SCAL> & a, AutoDiffRec<D,SCAL> b)
834 a.Last() -= b.Last();
839 template <
int D,
typename SCAL>
840 INLINE AutoDiffRec<D,SCAL> & operator*= (AutoDiffRec<D,SCAL> & a, AutoDiffRec<D,SCAL> b)
847 template <
int D,
typename SCAL,
typename SCAL2>
848 INLINE AutoDiffRec<D,SCAL> & operator*= (AutoDiffRec<D,SCAL> & b, SCAL2 a)
857 template <
typename SCAL>
858 auto Inv1 (SCAL x) {
return 1.0/x; }
860 template<
int D,
typename SCAL>
861 INLINE AutoDiffRec<D,SCAL>
Inv1 (AutoDiffRec<D,SCAL> x)
863 return AutoDiffRec<D,SCAL> (
Inv1(x.Rec()), (-
sqr(1.0/x.Value())) * x.Last());
867 template<
int D,
typename SCAL>
875 template<
int D,
typename SCAL,
typename SCAL2,
876 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
884 template<
int D,
typename SCAL,
typename SCAL2,
885 typename std::enable_if<std::is_convertible<SCAL2,SCAL>::value,
int>::type = 0>
898 template <
int D,
typename SCAL>
899 INLINE
bool operator== (AutoDiffRec<D,SCAL> x, SCAL val2)
901 return x.Value() == val2;
905 template <
int D,
typename SCAL>
906 INLINE
bool operator!= (AutoDiffRec<D,SCAL> x, SCAL val2)
throw()
908 return x.Value() != val2;
912 template <
int D,
typename SCAL>
913 INLINE
bool operator< (AutoDiffRec<D,SCAL> x, SCAL val2)
throw()
915 return x.Value() < val2;
919 template <
int D,
typename SCAL>
920 INLINE
bool operator> (AutoDiffRec<D,SCAL> x, SCAL val2)
throw()
922 return x.Value() > val2;
926 template<
int D,
typename SCAL>
927 INLINE AutoDiffRec<D,SCAL> fabs (
const AutoDiffRec<D,SCAL> & x)
929 auto sign = IfPos(x.Value(), SCAL(1.0), IfPos(-x.Value(), SCAL(-1.0), SCAL(0.0)));
930 return AutoDiffRec<D,SCAL> (fabs(x.Rec()), sign*x.Last());
946 template<
int D,
typename SCAL>
947 INLINE
auto sqrt (
const AutoDiffRec<D,SCAL> & x)
949 return AutoDiffRec<D,SCAL> (sqrt(x.Rec()), (0.5/sqrt(x.Value()))*x.Last());
954 template <
int D,
typename SCAL>
955 auto log (AutoDiffRec<D,SCAL> x)
957 return AutoDiffRec<D,SCAL> (log(x.Rec()), (1.0/x.Value())*x.Last());
960 template <
int D,
typename SCAL>
961 auto exp (AutoDiffRec<D,SCAL> x)
963 return AutoDiffRec<D,SCAL> (exp(x.Rec()), exp(x.Value())*x.Last());
966 template <
int D,
typename SCAL>
967 INLINE AutoDiffRec<D,SCAL> pow (AutoDiffRec<D,SCAL> x, AutoDiffRec<D,SCAL> y )
969 return exp(log(x)*y);
973 template <
int D,
typename SCAL>
974 auto sin (AutoDiffRec<D,SCAL> x)
976 return AutoDiffRec<D,SCAL> (sin(x.Rec()), cos(x.Value())*x.Last());
979 template <
int D,
typename SCAL>
980 auto cos (AutoDiffRec<D,SCAL> x)
982 return AutoDiffRec<D,SCAL> (cos(x.Rec()), -sin(x.Value())*x.Last());
985 template <
int D,
typename SCAL>
986 auto tan (AutoDiffRec<D,SCAL> x)
988 return sin(x) / cos(x);
991 template <
int D,
typename SCAL>
992 auto sinh (AutoDiffRec<D,SCAL> x)
994 return AutoDiffRec<D,SCAL> (sinh(x.Rec()), cosh(x.Value())*x.Last());
997 template <
int D,
typename SCAL>
998 auto cosh (AutoDiffRec<D,SCAL> x)
1000 return AutoDiffRec<D,SCAL> (cosh(x.Rec()), sinh(x.Value())*x.Last());
1003 template <
int D,
typename SCAL>
1004 auto floor (AutoDiffRec<D,SCAL> x)
1006 return AutoDiffRec<D,SCAL> (floor(x.Rec()), 0.0);
1009 template <
int D,
typename SCAL>
1010 auto ceil (AutoDiffRec<D,SCAL> x)
1012 return AutoDiffRec<D,SCAL> (ceil(x.Rec()), 0.0);
1017 template <
int D,
typename SCAL>
1018 auto atan (AutoDiffRec<D,SCAL> x)
1020 return AutoDiffRec<D,SCAL> (atan(x.Rec()), (1./(1.+x.Value()*x.Value()))*x.Last());
1023 template <
int D,
typename SCAL>
1024 auto atan2 (AutoDiffRec<D,SCAL> x, AutoDiffRec<D,SCAL> y)
1026 return AutoDiffRec<D,SCAL> (atan2(x.Rec(), y.Rec()),
1027 (1./(x.Value()*x.Value()+y.Value()*y.Value()))*(x.Value()*y.Last()-y.Value()*x.Last()));
1030 template <
int D,
typename SCAL>
1031 auto acos (AutoDiffRec<D,SCAL> x)
1033 return AutoDiffRec<D,SCAL> (acos(x.Rec()), (-1./sqrt(1.-x.Value()*x.Value()))*x.Last());
1036 template <
int D,
typename SCAL>
1037 auto asin (AutoDiffRec<D,SCAL> x)
1039 return AutoDiffRec<D,SCAL> (asin(x.Rec()), (1./sqrt(1.-x.Value()*x.Value()))*x.Last());
1043 template <
int D,
typename SCAL,
typename TB,
typename TC>
1044 auto IfPos (AutoDiffRec<D,SCAL> a, TB b, TC c)
1046 return IfPos (a.Value(), b, c);
1049 template <
int D,
typename SCAL>
1050 INLINE AutoDiffRec<D,SCAL> IfPos (SCAL a, AutoDiffRec<D,SCAL> b, AutoDiffRec<D,SCAL> c)
1059 return AutoDiffRec<D,SCAL> (IfPos(a, b.Rec(), c.Rec()), IfPos(a, b.Last(), c.Last()));
1062 template <
int D,
typename SCAL,
typename TC>
1063 INLINE AutoDiffRec<D,SCAL> IfPos (SCAL a, AutoDiffRec<D,SCAL> b, TC c)
1065 return IfPos (a, b, AutoDiffRec<D,SCAL> (c));
1070 template <
int D,
typename SCAL =
double>
1071 using AutoDiff = AutoDiffRec<D,SCAL>;