35#ifndef SACADO_TRADVEC_H
36#define SACADO_TRADVEC_H
44#if defined(RAD_DEBUG_BLOCKKEEP) && !defined(HAVE_SACADO_UNINIT)
45#undef RAD_DEBUG_BLOCKKEEP
49#ifndef RAD_AUTO_AD_Const
50#define RAD_AUTO_AD_Const
64#ifndef RAD_AUTO_AD_Const
65#ifdef RAD_DEBUG_BLOCKKEEP
73#ifdef RAD_AUTO_AD_Const
74#undef RAD_DEBUG_BLOCKKEEP
75#define Padvinit ,padv(0)
78#ifdef RAD_DEBUG_BLOCKKEEP
79#if !(RAD_DEBUG_BLOCKKEEP > 0)
80#undef RAD_DEBUG_BLOCKKEEP
88struct UninitType<float> {
89 static const int utype = 4;
93struct UninitType<double> {
94 static const int utype = 5;
98struct UninitType<
std::complex<T> > {
99 static const int utype = UninitType<T>::utype + 2;
108 template<
typename T>
class
121#define Dtype typename DoubleAvoid<Double>::dtype
122#define Ttype typename DoubleAvoid<Double>::ttype
124 template<
typename Double>
class IndepADvar;
125 template<
typename Double>
class ConstADvar;
126 template<
typename Double>
class ConstADvari;
127 template<
typename Double>
class ADvar;
128 template<
typename Double>
class ADvari;
129 template<
typename Double>
class ADvar1;
130 template<
typename Double>
class ADvar1s;
131 template<
typename Double>
class ADvar2;
132 template<
typename Double>
class ADvar2q;
133 template<
typename Double>
class ADvarn;
134 template<
typename Double>
class Derp;
136 template<
typename Double>
struct
144 template<
typename Double>
class
155 size_t ncur, nmax, rad_mleft_save;
156#ifdef RAD_DEBUG_BLOCKKEEP
160 void *new_ADmemblock(
size_t);
161 void derp_init(
size_t);
165 void *Memalloc(
size_t len);
166 static void Gradcomp();
168 static void Weighted_Gradcomp(
size_t,
ADVar**, Double*);
169 static void Weighted_GradcompVec(
size_t,
size_t*,
ADVar***, Double**);
170 static void Outvar_Gradcomp(
ADVar&);
173 template<
typename Double>
class
176 bool fpval_implies_const;
178 friend class ADvar<Double>;
182 template<
typename Double>
class
185 friend class ADvarn<Double>;
193 Derp(
const ADVari *);
194 Derp(
const Double *,
const ADVari *);
195 Derp(
const Double *,
const ADVari *,
const ADVari *);
196 inline void *
operator new(
size_t len) {
return (
Derp*)ADVari::adc.Memalloc(len); }
202#define Ai const ADvari<Double>&
203#define AI const IndepADvar<Double>&
204#define T template<typename Double>
231#define F ADvari<Double>&
278 template<
typename Double>ADvari<Double>&
ADf1(Double f, Double g,
const IndepADvar<Double> &
x);
279 template<
typename Double>ADvari<Double>&
ADf2(Double f, Double gx, Double gy,
280 const IndepADvar<Double> &
x,
const IndepADvar<Double> &
y);
281 template<
typename Double>ADvari<Double>&
ADfn(Double f,
int n,
282 const IndepADvar<Double> *
x,
const Double *g);
284 template<
typename Double> IndepADvar<Double>&
ADvar_operatoreq(IndepADvar<Double>*,
285 const ADvari<Double>&);
286 template<
typename Double> ADvar<Double>&
ADvar_operatoreq(ADvar<Double>*,
const ADvari<Double>&);
287 template<
typename Double>
void AD_Const(
const IndepADvar<Double>&);
288 template<
typename Double>
void AD_Const1(Double*,
const IndepADvar<Double>&);
289 template<
typename Double> ADvari<Double>&
ADf1(Double, Double,
const ADvari<Double>&);
290 template<
typename Double> ADvari<Double>&
ADf2(Double, Double, Double,
291 const ADvari<Double>&,
const ADvari<Double>&);
292 template<
typename Double> ADvari<Double>&
ADf2(Double, Double, Double,
293 const IndepADvar<Double>&,
const ADvari<Double>&);
294 template<
typename Double> ADvari<Double>&
ADf2(Double, Double, Double,
295 const ADvari<Double>&,
const IndepADvar<Double>&);
296 template<
typename Double> Double
val(
const ADvari<Double>&);
298 template<
typename Double>
class
304#ifdef RAD_AUTO_AD_Const
313 inline void ADvari_padv(
const IndepADVar *v) {
320 static int gcgen_cur, last_opno, zap_gcgen, zap_gcgen1, zap_opno;
321 static FILE *debug_file;
330 Last_ADvari = &this->Next;
333 void *
operator new(
size_t len) {
336 rv->gcgen = gcgen_cur;
337 rv->opno = ++last_opno;
338 if (last_opno == zap_opno && gcgen_cur == zap_gcgen)
339 printf(
"Got to opno %d\n", last_opno);
345 void operator delete(
void*) {}
347 inline ADvari(): Val(0.), aval(0)
Padvinit { Linkup(); }
348#ifdef RAD_AUTO_AD_Const
349 friend class ADcontext<Double>;
350 friend class ADvar<Double>;
351 friend class ADvar1<Double>;
352 friend class ADvar1s<Double>;
353 friend class ADvar2<Double>;
354 friend class ADvar2q<Double>;
355 friend class ConstADvar<Double>;
356 ADvari(
const IndepADVar *, Double);
360#define Ai const ADvari&
361#define T1(r,f) F r f <>(Ai);
366F r f <>(double,Ai); \
367F r f <>(Ai,double); \
413 friend ADvari& ADf1<>(Double f, Double g,
const ADvari &
x);
414 friend ADvari& ADf2<>(Double f, Double gx, Double gy,
const ADvari &
x,
const ADvari &
y);
415 friend ADvari& ADfn<>(Double f,
int n,
const IndepADVar *
x,
const Double *g);
417 inline operator Double() {
return this->Val; }
418 inline operator Double()
const {
return this->Val; }
423 template<
typename Double>
class
431 ADVari(val1), d(a1,this,c1) {}
432#ifdef RAD_AUTO_AD_Const
433 typedef typename ADVari::IndepADVar IndepADVar;
435 ADvar1(
const IndepADVar*,
const IndepADVar&);
436 ADvar1(
const IndepADVar*,
const ADVari&);
437 ADvar1(
const Double val1,
const Double *a1,
const ADVari *c1,
const ADVar *v):
438 ADVari(val1), d(a1,this,c1) {
440 this->ADvari_padv(v);
446 template<
typename Double>
class
457 inline void *
operator new(
size_t len) {
return ConstADvari::cadc.Memalloc(len); }
459 static void aval_reset(
void);
462 template<
typename Double>
class
470#ifdef RAD_AUTO_AD_Const
475#elif defined(RAD_EQ_ALIAS)
479 return ADvar_operatoreq(
this,*
x.cv);
485 friend class ADvar<Double>;
487 friend class ADvar1<Double>;
488 friend class ADvarn<Double>;
497#ifdef RAD_AUTO_AD_Const
499 inline IndepADvar() { cv = 0; }
500 inline ~IndepADvar() {
515 inline operator ADVari&()
const {
516 ADVari *tcv = this->cv;
521 inline operator ADVari*()
const {
522 ADVari *tcv = this->cv;
528 inline operator ADVari&()
const {
return *this->cv; }
529 inline operator ADVari*()
const {
return this->cv; }
532 inline Double
val()
const {
535 inline Double
adj()
const {
538 inline Double
adj(
int n)
const {
542 friend void AD_Const1<>(Double*,
const IndepADvar&);
544 friend ADVari& ADf1<>(Double, Double,
const IndepADvar&);
546 friend ADVari& ADf2<>(Double, Double, Double,
const ADVari&,
const IndepADvar&);
547 friend ADVari& ADf2<>(Double, Double, Double,
const IndepADvar&,
const ADVari&);
562#define Ai const ADVari&
563#define AI const IndepADvar&
577#define T1(f) friend ADVari& f<> (AI);
579#define F friend ADVari&
628 template<
typename Double>
class
638 void ADvar_ctr(Double d) {
640 if (ConstADVari::cadc.fpval_implies_const)
643#ifdef RAD_AUTO_AD_Const
645 x->ADvari_padv(
this);
653 friend class ADvar1<Double>;
657 inline ADvar(
double i) { ADvar_ctr(Double(
i)); }
659 inline ADvar(
long i) { ADvar_ctr(Double(
i)); }
661#ifdef RAD_AUTO_AD_Const
662 inline ADvar(IndepADVar &
x) {
663 this->cv =
x.cv ?
new ADVar1(
this,
x) : 0;
665 inline ADvar(ADVari &
x) { this->cv = &
x;
x.ADvari_padv(
this); }
666 inline ADvar& operator=(IndepADVar &
x) {
669 this->cv =
new ADVar1(
this,
x);
672 inline ADvar& operator=(ADVari &
x) {
675 this->cv =
new ADVar1(
this,
x);
679 friend ADvar& ADvar_operatoreq<>(ADvar*,
const ADVari&);
682 inline ADvar(
const IndepADVar &
x) {
683 this->cv = (ADVari*)
x.cv;
685 inline ADvar(
const ADVari &
x) { this->cv = (ADVari*)&
x; }
686 inline ADvar& operator=(IndepADVar &
x) {
687 this->cv = (ADVari*)
x.cv;
return *
this;
689 inline ADvar& operator=(
const ADVari &
x) { this->cv = (ADVari*)&
x;
return *
this; }
693 this->cv =
new ADVar1(
x.cv->Val, &this->cv->adc.One,
x.cv);
700 this->cv =
new ADVar1(
x.cv->Val, &this->cv->adc.One, (
ADVari*)
x.cv);
706 this->cv =
new ADVar1(
x.Val, &this->cv->adc.One, &
x);
711 ADvar& operator=(Double);
712 ADvar& operator+=(
const ADVari&);
713 ADvar& operator+=(Double);
714 ADvar& operator-=(
const ADVari&);
715 ADvar& operator-=(Double);
716 ADvar& operator*=(
const ADVari&);
717 ADvar& operator*=(Double);
718 ADvar& operator/=(
const ADVari&);
719 ADvar& operator/=(Double);
721 {
return ConstADVari::cadc.fpval_implies_const; }
723 { ConstADVari::cadc.fpval_implies_const = newval; }
725 bool oldval = ConstADVari::cadc.fpval_implies_const;
726 ConstADVari::cadc.fpval_implies_const = newval;
730 static inline void aval_reset() { ConstADVari::aval_reset(); }
739template<
typename Double>
743template<
typename Double>
746 template<
typename Double>
class
764 void ConstADvar_ctr(Double);
774#ifdef RAD_NO_CONST_UPDATE
788#define ADvar_nd ADvar
790 template<
typename Double>
class
797#ifdef RAD_AUTO_AD_Const
798 typedef typename ADVar1::ADVar
ADVar;
799 ADvar1s(Double val1, Double a1,
const ADVari *c1,
const ADVar *v):
800 ADVar1(val1,&
a,c1,v),
a(a1) {}
804 template<
typename Double>
class
812 const ADVari *Rcv,
const Double *Rc):
814 dR.
next = DErp::LastDerp;
816 DErp::LastDerp = &dL;
823#ifdef RAD_AUTO_AD_Const
825 ADvar2(Double val1,
const ADVari *Lcv,
const Double *Lc,
826 const ADVari *Rcv,
const Double *Rc,
ADVar *v):
828 dR.
next = DErp::LastDerp;
830 DErp::LastDerp = &dL;
837 this->ADvari_padv(v);
842 template<
typename Double>
class
851 this->dR.next = DErp::LastDerp;
852 this->dL.next = &this->dR;
853 DErp::LastDerp = &this->dL;
858 this->dL.b = this->dR.b =
this;
860#ifdef RAD_AUTO_AD_Const
861 typedef typename ADVar2::ADVar
ADVar;
862 ADvar2q(Double val1, Double Lp, Double Rp,
const ADVari *Lcv,
863 const ADVari *Rcv,
const ADVar *v):
864 ADVar2(val1),
a(Lp), b(Rp) {
865 this->dR.next = DErp::LastDerp;
866 this->dL.next = &this->dR;
867 DErp::LastDerp = &this->dL;
872 this->dL.b = this->dR.b =
this;
874 this->ADvari_padv(v);
879 template<
typename Double>
class
894 a1 =
a = (Double*)ADVari::adc.Memalloc(n*
sizeof(*
a));
895 d1 = Da = (
DErp*)ADVari::adc.Memalloc(n*
sizeof(
DErp));
896 dlast = DErp::LastDerp;
897 for(
i = 0;
i < n1;
i++, d1++) {
905 DErp::LastDerp = dlast;
909template<
typename Double>
912template<
typename Double>
914template<
typename Double>
916template<
typename Double>
919template<
typename Double>
921template<
typename Double>
923template<
typename Double>
926template<
typename Double>
928template<
typename Double>
930template<
typename Double>
933template<
typename Double>
935template<
typename Double>
937template<
typename Double>
940template<
typename Double>
942template<
typename Double>
944template<
typename Double>
947template<
typename Double>
949template<
typename Double>
951template<
typename Double>
954template<
typename Double>
957 return Mbase + (Mleft -= len);
958 return new_ADmemblock(len);
961template<
typename Double>
967template<
typename Double>
974template<
typename Double>
993#ifndef RAD_DEBUG_gcgen1
994#define RAD_DEBUG_gcgen1 -1
1011 Mbase = (
char*)First->
memblk;
1012 Mleft =
sizeof(First->memblk);
1013 ncur = nmax = rad_need_reinit = 0;
1014#ifdef RAD_DEBUG_BLOCKKEEP
1015 rad_busy_blocks = 0;
1021template<
typename Double>
void*
1025#ifdef RAD_AUTO_AD_Const
1028#ifdef RAD_Const_WARN
1034 if (rad_need_reinit &&
this == &ADVari::adc) {
1035 rad_need_reinit = 0;
1038 ADVari::Last_ADvari = &ADVari::First_ADvari;
1039#ifdef RAD_DEBUG_BLOCKKEEP
1040 Mleft = rad_mleft_save;
1041 if (Mleft <
sizeof(First->memblk))
1043 UninitType<Double>::utype,
1044 (
sizeof(First->memblk) - Mleft)
1046 if ((mb = Busy->
next)) {
1048 for(;; mb = mb->
next) {
1050 UninitType<Double>::utype,
1051 sizeof(First->memblk)
1057 rad_Oldcurmb = Busy;
1058 if (rad_busy_blocks >= RAD_DEBUG_BLOCKKEEP) {
1059 rad_busy_blocks = 0;
1063 for(mb = Busy; mb != mb0; mb = mb1) {
1070 Mbase = (
char*)First->
memblk;
1071 Mleft =
sizeof(First->memblk);
1078 for(mb = Busy; mb != mb0; mb = mb1) {
1085 Mbase = (
char*)First->
memblk;
1086 Mleft =
sizeof(First->memblk);
1088#ifdef RAD_AUTO_AD_Const
1089 if ((
a = ADVari::First_ADvari)) {
1093#ifdef RAD_Const_WARN
1094 if ((
i =
a->opno) > 0)
1109 return Mbase + (Mleft -= len);
1116#ifdef RAD_DEBUG_BLOCKKEEP
1121 return (Mbase = (
char*)
x->memblk) +
1122 (Mleft =
sizeof(First->memblk) - len);
1125 template<
typename Double>
void
1134 if (!rad_need_reinit) {
1135 rad_mleft_save = Mleft;
1138 len = n *
sizeof(Double);
1144 else if (n > nmax) {
1158 Mleft = rad_mleft_save;
1161 rad_need_reinit = 0;
1163 *ADVari::Last_ADvari = 0;
1164 for(
a = ADVari::First_ADvari;
a;
a =
a->Next) {
1165 d =
a->aval = (Double*)Memalloc(len);
1167 do *d = 0.;
while(++d < de);
1170 d =
c->aval = (Double*)Memalloc(len);
1172 do *d = 0.;
while(++d < de);
1177 for(
a = ADVari::First_ADvari;
a;
a =
a->Next)
1180 else for(
a = ADVari::First_ADvari;
a;
a =
a->Next) {
1183 do *d = 0.;
while(++d < de);
1186 rad_need_reinit = 1;
1188 if (ADVari::gcgen_cur == ADVari::zap_gcgen1) {
1190 if (!(fname = getenv(
"RAD_DEBUG_FILE")))
1191 fname =
"rad_debug.out";
1195 ADVari::debug_file = fopen(fname,
"w");
1196 ADVari::zap_gcgen1 = -1;
1201 template<
typename Double>
void
1205#ifdef RAD_AUTO_AD_Const
1208#ifdef RAD_Const_WARN
1214 ADVari::adc.derp_init(1);
1215 if ((d = DErp::LastDerp) != 0) {
1218 if (ADVari::debug_file)
1220 fprintf(ADVari::debug_file,
"%d\t%d\t%g + %g * %g",
1223 fprintf(ADVari::debug_file,
" = %g\n", *d->
c->
aval);
1224 }
while((d = d->
next));
1228 while((d = d->
next));
1231 if (ADVari::debug_file) {
1232 fclose(ADVari::debug_file);
1233 ADVari::debug_file = 0;
1235 ADVari::gcgen_cur++;
1236 ADVari::last_opno = 0;
1240 template<
typename Double>
void
1245#ifdef RAD_AUTO_AD_Const
1248#ifdef RAD_Const_WARN
1254 ADVari::adc.derp_init(1);
1256 if ((d = DErp::LastDerp) != 0) {
1257 for(
i = 0;
i < n;
i++)
1260 if (ADVari::debug_file)
1262 fprintf(ADVari::debug_file,
"%d\t%d\t%g + %g * %g",
1265 fprintf(ADVari::debug_file,
" = %g\n", *d->
c->
aval);
1266 }
while((d = d->
next));
1270 while((d = d->
next));
1273 if (ADVari::debug_file) {
1274 fclose(ADVari::debug_file);
1275 ADVari::debug_file = 0;
1277 if (ADVari::debug_file)
1278 fflush(ADVari::debug_file);
1279 ADVari::gcgen_cur++;
1280 ADVari::last_opno = 0;
1284 template<
typename Double>
void
1290 Double
A, *
D, *D1, *De, *wi;
1291#ifdef RAD_AUTO_AD_Const
1294#ifdef RAD_Const_WARN
1300 ADVari::adc.derp_init(n);
1304 if ((d = DErp::LastDerp) != 0) {
1305 for(
i = 0;
i < n;
i++) {
1309 for(ii = 0; ii < ni; ++ii)
1310 Vi[ii]->cv->
aval[
i] = wi[ii];
1313 if (ADVari::debug_file)
1319 for(
i = 0;
i < n; ++
i, ++
D, ++D1) {
1320 fprintf(ADVari::debug_file,
"%d:\t%d\t%d\t%g + %g * %g",
1321 i, d->
c->opno, d->
b->opno, *
D, A, *D1);
1323 fprintf(ADVari::debug_file,
" = %g\n", *
D);
1325 }
while((d = d->
next));
1333 do *
D++ += A * *D1++;
while(
D < De);
1335 while((d = d->
next));
1338 if (ADVari::debug_file) {
1339 fclose(ADVari::debug_file);
1340 ADVari::debug_file = 0;
1342 if (ADVari::debug_file)
1343 fflush(ADVari::debug_file);
1344 ADVari::gcgen_cur++;
1345 ADVari::last_opno = 0;
1349 template<
typename Double>
void
1357 template<
typename Double>
1363 template<
typename Double>
1369 template<
typename Double>
1375 template<
typename Double>
1381 template<
typename Double>
1387 template<
typename Double>
void
1393 template<
typename Double>
1401 template<
typename Double>
1409 template<
typename Double>
1417 template<
typename Double>
1423 ConstADVari *ncv =
new ConstADVari(v.
val());
1424#ifdef RAD_AUTO_AD_Const
1430 template<
typename Double>
1437 template<
typename Double>
1448#ifdef RAD_AUTO_AD_Const
1450 template<
typename Double>
1453 this->ADvari_padv(
x);
1457 template<
typename Double>
1459 ADVari(
y.cv->Val), d((const Double*)&ADcontext<Double>::One, (ADVari*)this,
y.cv)
1461 this->ADvari_padv(
x);
1464 template<
typename Double>
1466 ADVari(
y.Val), d((const Double*)&ADcontext<Double>::One, this, &
y)
1468 this->ADvari_padv(
x);
1473 template<
typename Double>
1481 template<
typename Double>
1492 template<
typename Double>
1496#ifdef RAD_AUTO_AD_Const
1499 this->cv =
new ADVari(
this,d);
1501 this->cv =
new ADVari(d);
1506 template<
typename Double>
1510#ifdef RAD_AUTO_AD_Const
1513 this->cv =
new ADVari(
this,d);
1515 this->cv = ConstADVari::cadc.fpval_implies_const
1522 template<
typename Double>
1528 template<
typename Double>
1534#ifdef RAD_AUTO_AD_Const
1535#define RAD_ACA ,this
1540 template<
typename Double>
1548 template<
typename Double>
1554 template<
typename Double>
1562 template<
typename Double>
1568 template<
typename Double>
1574 template<
typename Double>
1582 template<
typename Double>
1588 template<
typename Double>
1596 template<
typename Double>
1602 template<
typename Double>
1608 template<
typename Double>
1616 template<
typename Double>
1622 template<
typename Double>
1630 template<
typename Double>
1636 template<
typename Double>
1639 Double Lv = L.
Val, Rv =
R.Val, pL = 1. / Rv, q = Lv/Rv;
1643 template<
typename Double>
1647 Double Lv = Lcv->
Val, Rv =
R.Val, pL = 1. / Rv, q = Lv/Rv;
1652 template<
typename Double>
1658 template<
typename Double>
1661 Double recip = 1. /
R.Val;
1662 Double q = L * recip;
1666 template<
typename Double>
1674 template<
typename Double>
1678 return *(
new ADvar1s<Double>(std::acos(t), -1./std::sqrt(1. - t*t), &v));
1681 template<
typename Double>
1684 Double t = v.
Val, t1 = std::sqrt(t*t - 1.);
1688 template<
typename Double>
1692 return *(
new ADvar1s<Double>(std::asin(t), 1./std::sqrt(1. - t*t), &v));
1695 template<
typename Double>
1698 Double t = v.
Val, td = 1., t1 = std::sqrt(t*t + 1.);
1706 template<
typename Double>
1713 template<
typename Double>
1717 return *(
new ADvar1s<Double>(0.5*std::log((1.+t)/(1.-t)), 1./(1. - t*t), &v));
1720 template<
typename Double>
1727 template<
typename Double>
1730 Double
y =
R.Val, t =
x*
x +
y*
y;
1734 template<
typename Double>
1741 template<
typename Double>
1748 template<
typename Double>
1756 template<
typename Double>
1764 template<
typename Double>
1771 template<
typename Double>
1779 template<
typename Double>
1787 template<
typename Double>
1793 template<
typename Double>
1799 template<
typename Double>
1803 rcv->
d.a = &rcv->
Val;
1808 template<
typename Double>
1815 template<
typename Double>
1818 static double num = 1. / std::log(10.);
1823 template<
typename Double>
1826 Double
x = L.
Val,
y =
R.Val, t = std::pow(
x,
y);
1830 template<
typename Double>
1833 Double t = std::pow(
x,
R.Val);
1837 template<
typename Double>
1840 Double
x = L.
Val, t = std::pow(
x,
y);
1844 template<
typename Double>
1850 template<
typename Double>
1856 template<
typename Double>
1859 Double t = std::sqrt(v.
Val);
1863 template<
typename Double>
1866 Double t = std::cos(v.
Val);
1870 template<
typename Double>
1873 Double t = 1. / std::cosh(v.
Val);
1877 template<
typename Double>
1882 if ((t = v.
Val) < 0) {
1889 template<
typename Double>
1896 if ((t = v.
Val) < 0) {
1903 template<
typename Double>
1909 template<
typename Double>
1910 inline ADvari<Double>&
1915 template<
typename Double>
1921 template<
typename Double>
1927 template<
typename Double>
1933 template<
typename Double>
1939 template<
typename Double>
1945 template<
typename Double>
1951 template<
typename Double>
1958#define A (ADvari<Double>*)
1959#ifdef RAD_Const_WARN
1960#define C(x) (((x)->opno < 0) ? RAD_Const_Warn(x) : 0, *A x)
1964#define T template<typename Double> inline
1965#define F ADvari<Double>&
1966#define Ai const ADvari<Double>&
1967#define AI const IndepADvar<Double>&
1970 T r f(Ai L, AI R) { return f(L, C(R.cv)); }\
1971 T r f(AI L, Ai R) { return f(C(L.cv), R); }\
1972 T r f(AI L, AI R) { return f(C(L.cv), C(R.cv)); }\
1973 T r f(AI L, D R) { return f(C(L.cv), R); }\
1974 T r f(Ai L, Dtype R) { return f(L, (D)R); }\
1975 T r f(AI L, Dtype R) { return f(C(L.cv), (D)R); }\
1976 T r f(Ai L, long R) { return f(L, (D)R); }\
1977 T r f(AI L, long R) { return f(C(L.cv), (D)R); }\
1978 T r f(Ai L, int R) { return f(L, (D)R); }\
1979 T r f(AI L, int R) { return f(C(L.cv), (D)R); }\
1980 T r f(D L, AI R) { return f(L, C(R.cv)); }\
1981 T r f(Dtype L, Ai R) { return f((D)L, R); }\
1982 T r f(Dtype L, AI R) { return f((D)L, C(R.cv)); }\
1983 T r f(long L, Ai R) { return f((D)L, R); }\
1984 T r f(long L, AI R) { return f((D)L, C(R.cv)); }\
1985 T r f(int L, Ai R) { return f((D)L, R); }\
1986 T r f(int L, AI R) { return f((D)L, C(R.cv)); }
2007 T F f(AI x) { return f(C(x.cv)); }
int RAD_Const_Warn(void *v)
expr expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c *expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr1 c expr2 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr2 expr1 expr2 expr1 expr1 expr1 expr2 expr1 expr2 expr1 expr1 expr1 c
static void Weighted_Gradcomp(size_t, ADVar **, Double *)
static void Outvar_Gradcomp(ADVar &)
static const Double negOne
void * new_ADmemblock(size_t)
static void aval_reset(void)
static void Weighted_GradcompVec(size_t, size_t *, ADVar ***, Double **)
ADmemblock< Double > ADMemblock
ADvar1(Double val1, const Double *a1, const ADVari *c1)
ADvar1(Double val1, const ADVari *c1)
ADvar1s(Double val1, Double a1, const ADVari *c1)
ADvar2(Double val1, const ADVari *Lcv, const Double *Lc, const ADVari *Rcv, const Double *Rc)
ADvar2q(Double val1, Double Lp, Double Rp, const ADVari *Lcv, const ADVari *Rcv)
ADvar & operator+=(const ADVari &)
static void Weighted_Gradcomp(size_t n, ADvar **v, Double *w)
static void set_fpval_implies_const(bool newval)
static void Outvar_Gradcomp(ADvar &v)
ADvar & operator=(const ADVari &x)
ADvar(const IndepADVar &x)
ADvar & operator-=(const ADVari &)
ConstADvari< Double > ConstADVari
IndepADvar< Double > IndepADVar
IndepADVar::ADVari ADVari
static bool setget_fpval_implies_const(bool newval)
ADvar & operator*=(const ADVari &)
ADvar & operator/=(const ADVari &)
static bool get_fpval_implies_const(void)
static void Weighted_GradcompVec(size_t n, size_t *np, ADvar ***v, Double **w)
IndepADvar< Double > IndepADVar
static ADvari * First_ADvari
static ADcontext< Double > adc
ScalarType< value_type >::type scalar_type
ADVari::IndepADVar IndepADVar
ADvarn(Double val1, int n1, const IndepADVar *x, const Double *g)
ConstADvar & operator*=(ADVari &)
ConstADvar & operator+=(Double)
ConstADvar & operator-=(Double)
void ConstADvar_ctr(Double)
ADVar::ConstADVari ConstADVari
ConstADvar & operator=(Double d)
ConstADvar & operator/=(Double)
ConstADvar & operator=(ADVari &d)
ConstADvar & operator-=(ADVari &)
ConstADvar & operator*=(Double)
ConstADvar & operator/=(ADVari &)
ADVar::IndepADVar IndepADVar
ConstADvar & operator+=(ADVari &)
static void aval_reset(void)
static CADcontext< Double > cadc
static ConstADvari * lastcad
static void AD_Const(const IndepADvar &)
static void Weighted_Gradcomp(size_t n, ADVar **v, Double *w)
static void Outvar_Gradcomp(ADVar &v)
IndepADvar & operator=(IndepADvar &x)
static void Weighted_GradcompVec(size_t n, size_t *np, ADVar ***v, Double **w)
ADvari< Double > & acos(const ADvari< Double > &v)
ADvari< Double > & min(const ADvari< Double > &L, const ADvari< Double > &R)
ADvari< Double > & log(const ADvari< Double > &v)
IndepADvar< Double > & ADvar_operatoreq(IndepADvar< Double > *, const ADvari< Double > &)
ADvari< Double > & ADf1(Double f, Double g, const IndepADvar< Double > &x)
ADvari< Double > & asinh(const ADvari< Double > &v)
void AD_Const1(Double *, const IndepADvar< Double > &)
ADvari< Double > & sinh(const ADvari< Double > &v)
ADvari< Double > & sin(const ADvari< Double > &v)
ADvari< Double > & cos(const ADvari< Double > &v)
ADvari< Double > & atanh(const ADvari< Double > &v)
ADvari< Double > & exp(const ADvari< Double > &v)
ADvari< Double > & tan(const ADvari< Double > &v)
ADvari< Double > & operator-(const ADvari< Double > &T)
void AD_Const(const IndepADvar< Double > &)
ADvari< Double > & operator*(const ADvari< Double > &L, const ADvari< Double > &R)
ADvari< Double > & tanh(const ADvari< Double > &v)
ADvari< Double > & abs(const ADvari< Double > &v)
ADvari< Double > & pow(const ADvari< Double > &L, const ADvari< Double > &R)
ADvari< Double > & ADf2(Double f, Double gx, Double gy, const IndepADvar< Double > &x, const IndepADvar< Double > &y)
ADvari< Double > & atan(const ADvari< Double > &v)
ADvari< Double > & ADfn(Double f, int n, const IndepADvar< Double > *x, const Double *g)
ADvari< Double > & acosh(const ADvari< Double > &v)
ADvari< Double > & operator/(const ADvari< Double > &L, const ADvari< Double > &R)
ADvari< Double > & operator+(const ADvari< Double > &T)
ADvari< Double > & max(const ADvari< Double > &L, const ADvari< Double > &R)
ADvari< Double > & fabs(const ADvari< Double > &v)
ADvari< Double > & log10(const ADvari< Double > &v)
ADvari< Double > & asin(const ADvari< Double > &v)
ADvari< Double > & cosh(const ADvari< Double > &v)
ADvari< Double > & atan2(const ADvari< Double > &L, const ADvari< Double > &R)
ADvari< Double > & sqrt(const ADvari< Double > &v)
bool operator==(const Handle< T > &h1, const Handle< T > &h2)
Compare two handles.
Turn ADvar into a meta-function class usable with mpl::apply.
ADT_RAD IndepADvar< double > AI
ADT_RAD ADvari< double > Ai
Sacado::RadVec::ADvar< double > ADVar
void _uninit_f2c(void *x, int type, long len)