Sacado Package Browser (Single Doxygen Collection): tradoptest

Go to the documentation of this file.
00001 
00002 
00003 /* Try to test all combinations of types and operations */
00004 
00005 
00006 
00007 #define ADT_RAD Sacado::Rad::
00008 
00009 
00010 
00011 #include "Sacado_trad.hpp"
00012 
00013 #include <cstdio>
00014 
00015 using std::printf;
00016 
00017 
00018 
00019 typedef ADT_RAD IndepADvar<double> AI;
00020 
00021 typedef ADT_RAD ADvar<double> A;
00022 
00023 typedef ADT_RAD ConstADvar<double> C;
00024 
00025 typedef ADT_RAD ADvari<double> Ai;
00026 
00027 typedef const ADT_RAD IndepADvar<double> cAI;
00028 
00029 typedef const ADT_RAD ADvar<double> cA;
00030 
00031 typedef const ADT_RAD ConstADvar<double> cC;
00032 
00033 typedef const ADT_RAD ADvari<double> cAi;
00034 
00035 static int rc;
00036 
00037 
00038 
00039 /* This is to be run through an awk program that changes lines */
00040 
00041 /* with "BINTEST" or "UNOPTEST" at the beginning of the line into */
00042 
00043 /* a the desired C++ (which we can then inspect). */
00044 
00045 
00046 
00047  void
00048 
00049 botch(const char *what, double wanted, double got)
00050 
00051 {
00052 
00053   printf("%s: expected %g, got %g, diff = %.2g\n", what, wanted, got, wanted-got);
00054 
00055   rc = 1;
00056 
00057   }
00058 
00059 
00060 
00061  const double tol = 5e-16;
00062 
00063 
00064 
00065  int
00066 
00067 differ(double a, double b)
00068 
00069 {
00070 
00071   double d = a - b;
00072 
00073   if (d < 0.)
00074 
00075     d = -d;
00076 
00077   if (a < 0.)
00078 
00079     a = -a;
00080 
00081   if (b < 0.)
00082 
00083     b = -b;
00084 
00085   if (a < b)
00086 
00087     a = b;
00088 
00089   if (a > 0.)
00090 
00091     d /= a;
00092 
00093   return d > tol;
00094 
00095   }
00096 
00097 
00098 
00099 #ifndef RAD_EQ_ALIAS
00100 
00101 #define Plus_dx 1.
00102 
00103 #else
00104 
00105 #ifdef RAD_AUTO_AD_Const
00106 
00107 #define Plus_dx 1.
00108 
00109 #else
00110 
00111 #define Plus_dx 0.
00112 
00113 #endif
00114 
00115 #endif
00116 
00117 
00118 
00119  int
00120 
00121 main(void)
00122 
00123 {
00124 
00125   AI xAI, yAI;
00126 
00127   A fA, xA, yA;
00128 
00129   C xC, yC;
00130 
00131   double dx, dy, f, xd, yd;
00132 
00133   long xL, yL;
00134 
00135   int xi, yi;
00136 
00137 
00138 
00139   rc = 0;
00140 
00141 
00142   /**** Test of operator* ****/
00143 
00144   xd = 6.; yd = 7.; f = 42.; dx = 7.; dy = 6.;
00145   xAI = xd;
00146   yAI = yd;
00147   fA = operator*(xAI,yAI);
00148   A::Gradcomp();
00149   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yAI)", f, fA.val());
00150   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yAI)/dx", dx, xAI.adj());
00151   else if (differ(yAI.adj(), dy)) botch("d operator*(xAI,yAI)/dy", dy, yAI.adj());
00152   {
00153   A::aval_reset();
00154   cAI xcAI(xd);
00155   yAI = yd;
00156   fA = operator*(xcAI,yAI);
00157   A::Gradcomp();
00158   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yAI)", f, fA.val());
00159   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yAI)/dx", dx, xcAI.adj());
00160   else if (differ(yAI.adj(), dy)) botch("d operator*(xcAI,yAI)/dy", dy, yAI.adj());
00161   }
00162   {
00163   A::aval_reset();
00164   xAI = xd;
00165   cAI ycAI(yd);
00166   fA = operator*(xAI,ycAI);
00167   A::Gradcomp();
00168   if (differ(fA.val(), f)) botch("fA = operator*(xAI,ycAI)", f, fA.val());
00169   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,ycAI)/dx", dx, xAI.adj());
00170   else if (differ(ycAI.adj(), dy)) botch("d operator*(xAI,ycAI)/dy", dy, ycAI.adj());
00171   }
00172   {
00173   A::aval_reset();
00174   cAI xcAI(xd);
00175   cAI ycAI(yd);
00176   fA = operator*(xcAI,ycAI);
00177   A::Gradcomp();
00178   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,ycAI)", f, fA.val());
00179   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,ycAI)/dx", dx, xcAI.adj());
00180   else if (differ(ycAI.adj(), dy)) botch("d operator*(xcAI,ycAI)/dy", dy, ycAI.adj());
00181   }
00182   xAI = xd;
00183   yA = yd;
00184   fA = operator*(xAI,yA);
00185   A::Gradcomp();
00186   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yA)", f, fA.val());
00187   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yA)/dx", dx, xAI.adj());
00188   else if (differ(yA.adj(), dy)) botch("d operator*(xAI,yA)/dy", dy, yA.adj());
00189   {
00190   A::aval_reset();
00191   cAI xcAI(xd);
00192   yA = yd;
00193   fA = operator*(xcAI,yA);
00194   A::Gradcomp();
00195   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yA)", f, fA.val());
00196   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yA)/dx", dx, xcAI.adj());
00197   else if (differ(yA.adj(), dy)) botch("d operator*(xcAI,yA)/dy", dy, yA.adj());
00198   }
00199   {
00200   A::aval_reset();
00201   xAI = xd;
00202   cA ycA(yd);
00203   fA = operator*(xAI,ycA);
00204   A::Gradcomp();
00205   if (differ(fA.val(), f)) botch("fA = operator*(xAI,ycA)", f, fA.val());
00206   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,ycA)/dx", dx, xAI.adj());
00207   else if (differ(ycA.adj(), dy)) botch("d operator*(xAI,ycA)/dy", dy, ycA.adj());
00208   }
00209   {
00210   A::aval_reset();
00211   cAI xcAI(xd);
00212   cA ycA(yd);
00213   fA = operator*(xcAI,ycA);
00214   A::Gradcomp();
00215   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,ycA)", f, fA.val());
00216   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,ycA)/dx", dx, xcAI.adj());
00217   else if (differ(ycA.adj(), dy)) botch("d operator*(xcAI,ycA)/dy", dy, ycA.adj());
00218   }
00219   xAI = xd;
00220   yC = yd;
00221   fA = operator*(xAI,yC);
00222   A::Gradcomp();
00223   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yC)", f, fA.val());
00224   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yC)/dx", dx, xAI.adj());
00225   else if (differ(yC.adj(), dy)) botch("d operator*(xAI,yC)/dy", dy, yC.adj());
00226   {
00227   A::aval_reset();
00228   cAI xcAI(xd);
00229   yC = yd;
00230   fA = operator*(xcAI,yC);
00231   A::Gradcomp();
00232   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yC)", f, fA.val());
00233   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yC)/dx", dx, xcAI.adj());
00234   else if (differ(yC.adj(), dy)) botch("d operator*(xcAI,yC)/dy", dy, yC.adj());
00235   }
00236   {
00237   A::aval_reset();
00238   xAI = xd;
00239   cC ycC(yd);
00240   fA = operator*(xAI,ycC);
00241   A::Gradcomp();
00242   if (differ(fA.val(), f)) botch("fA = operator*(xAI,ycC)", f, fA.val());
00243   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,ycC)/dx", dx, xAI.adj());
00244   else if (differ(ycC.adj(), dy)) botch("d operator*(xAI,ycC)/dy", dy, ycC.adj());
00245   }
00246   {
00247   A::aval_reset();
00248   cAI xcAI(xd);
00249   cC ycC(yd);
00250   fA = operator*(xcAI,ycC);
00251   A::Gradcomp();
00252   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,ycC)", f, fA.val());
00253   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,ycC)/dx", dx, xcAI.adj());
00254   else if (differ(ycC.adj(), dy)) botch("d operator*(xcAI,ycC)/dy", dy, ycC.adj());
00255   }
00256   {
00257   xAI = xd;
00258   Ai yAi(yd);
00259   fA = operator*(xAI,yAi);
00260   A::Gradcomp();
00261   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yAi)", f, fA.val());
00262   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yAi)/dx", dx, xAI.adj());
00263   else if (differ(yAi.aval, dy)) botch("d operator*(xAI,yAi)/dy", dy, yAi.aval);
00264   }
00265   {
00266   A::aval_reset();
00267   cAI xcAI(xd);
00268   Ai yAi(yd);
00269   fA = operator*(xcAI,yAi);
00270   A::Gradcomp();
00271   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yAi)", f, fA.val());
00272   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yAi)/dx", dx, xcAI.adj());
00273   else if (differ(yAi.aval, dy)) botch("d operator*(xcAI,yAi)/dy", dy, yAi.aval);
00274   }
00275   {
00276   A::aval_reset();
00277   xAI = xd;
00278   cAi ycAi(yd);
00279   fA = operator*(xAI,ycAi);
00280   A::Gradcomp();
00281   if (differ(fA.val(), f)) botch("fA = operator*(xAI,ycAi)", f, fA.val());
00282   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,ycAi)/dx", dx, xAI.adj());
00283   else if (differ(ycAi.aval, dy)) botch("d operator*(xAI,ycAi)/dy", dy, ycAi.aval);
00284   }
00285   {
00286   A::aval_reset();
00287   cAI xcAI(xd);
00288   cAi ycAi(yd);
00289   fA = operator*(xcAI,ycAi);
00290   A::Gradcomp();
00291   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,ycAi)", f, fA.val());
00292   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,ycAi)/dx", dx, xcAI.adj());
00293   else if (differ(ycAi.aval, dy)) botch("d operator*(xcAI,ycAi)/dy", dy, ycAi.aval);
00294   }
00295   xAI = xd;
00296   fA = operator*(xAI,yd);
00297   A::Gradcomp();
00298   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yd)", f, fA.val());
00299   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yd)/dx", dx, xAI.adj());
00300   {
00301   A::aval_reset();
00302   cAI xcAI(xd);
00303   fA = operator*(xcAI,yd);
00304   A::Gradcomp();
00305   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yd)", f, fA.val());
00306   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yd)/dx", dx, xcAI.adj());
00307   }
00308   xAI = xd;
00309   yL = (long)yd;
00310   fA = operator*(xAI,yL);
00311   A::Gradcomp();
00312   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yL)", f, fA.val());
00313   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yL)/dx", dx, xAI.adj());
00314   {
00315   A::aval_reset();
00316   cAI xcAI(xd);
00317   yL = (long)yd;
00318   fA = operator*(xcAI,yL);
00319   A::Gradcomp();
00320   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yL)", f, fA.val());
00321   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yL)/dx", dx, xcAI.adj());
00322   }
00323   xAI = xd;
00324   yi = (int)yd;
00325   fA = operator*(xAI,yi);
00326   A::Gradcomp();
00327   if (differ(fA.val(), f)) botch("fA = operator*(xAI,yi)", f, fA.val());
00328   else if (differ(xAI.adj(), dx)) botch("d operator*(xAI,yi)/dx", dx, xAI.adj());
00329   {
00330   A::aval_reset();
00331   cAI xcAI(xd);
00332   yi = (int)yd;
00333   fA = operator*(xcAI,yi);
00334   A::Gradcomp();
00335   if (differ(fA.val(), f)) botch("fA = operator*(xcAI,yi)", f, fA.val());
00336   else if (differ(xcAI.adj(), dx)) botch("d operator*(xcAI,yi)/dx", dx, xcAI.adj());
00337   }
00338   xA = xd;
00339   yAI = yd;
00340   fA = operator*(xA,yAI);
00341   A::Gradcomp();
00342   if (differ(fA.val(), f)) botch("fA = operator*(xA,yAI)", f, fA.val());
00343   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yAI)/dx", dx, xA.adj());
00344   else if (differ(yAI.adj(), dy)) botch("d operator*(xA,yAI)/dy", dy, yAI.adj());
00345   {
00346   A::aval_reset();
00347   cA xcA(xd);
00348   yAI = yd;
00349   fA = operator*(xcA,yAI);
00350   A::Gradcomp();
00351   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yAI)", f, fA.val());
00352   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yAI)/dx", dx, xcA.adj());
00353   else if (differ(yAI.adj(), dy)) botch("d operator*(xcA,yAI)/dy", dy, yAI.adj());
00354   }
00355   {
00356   A::aval_reset();
00357   xA = xd;
00358   cAI ycAI(yd);
00359   fA = operator*(xA,ycAI);
00360   A::Gradcomp();
00361   if (differ(fA.val(), f)) botch("fA = operator*(xA,ycAI)", f, fA.val());
00362   else if (differ(xA.adj(), dx)) botch("d operator*(xA,ycAI)/dx", dx, xA.adj());
00363   else if (differ(ycAI.adj(), dy)) botch("d operator*(xA,ycAI)/dy", dy, ycAI.adj());
00364   }
00365   {
00366   A::aval_reset();
00367   cA xcA(xd);
00368   cAI ycAI(yd);
00369   fA = operator*(xcA,ycAI);
00370   A::Gradcomp();
00371   if (differ(fA.val(), f)) botch("fA = operator*(xcA,ycAI)", f, fA.val());
00372   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,ycAI)/dx", dx, xcA.adj());
00373   else if (differ(ycAI.adj(), dy)) botch("d operator*(xcA,ycAI)/dy", dy, ycAI.adj());
00374   }
00375   xA = xd;
00376   yA = yd;
00377   fA = operator*(xA,yA);
00378   A::Gradcomp();
00379   if (differ(fA.val(), f)) botch("fA = operator*(xA,yA)", f, fA.val());
00380   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yA)/dx", dx, xA.adj());
00381   else if (differ(yA.adj(), dy)) botch("d operator*(xA,yA)/dy", dy, yA.adj());
00382   {
00383   A::aval_reset();
00384   cA xcA(xd);
00385   yA = yd;
00386   fA = operator*(xcA,yA);
00387   A::Gradcomp();
00388   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yA)", f, fA.val());
00389   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yA)/dx", dx, xcA.adj());
00390   else if (differ(yA.adj(), dy)) botch("d operator*(xcA,yA)/dy", dy, yA.adj());
00391   }
00392   {
00393   A::aval_reset();
00394   xA = xd;
00395   cA ycA(yd);
00396   fA = operator*(xA,ycA);
00397   A::Gradcomp();
00398   if (differ(fA.val(), f)) botch("fA = operator*(xA,ycA)", f, fA.val());
00399   else if (differ(xA.adj(), dx)) botch("d operator*(xA,ycA)/dx", dx, xA.adj());
00400   else if (differ(ycA.adj(), dy)) botch("d operator*(xA,ycA)/dy", dy, ycA.adj());
00401   }
00402   {
00403   A::aval_reset();
00404   cA xcA(xd);
00405   cA ycA(yd);
00406   fA = operator*(xcA,ycA);
00407   A::Gradcomp();
00408   if (differ(fA.val(), f)) botch("fA = operator*(xcA,ycA)", f, fA.val());
00409   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,ycA)/dx", dx, xcA.adj());
00410   else if (differ(ycA.adj(), dy)) botch("d operator*(xcA,ycA)/dy", dy, ycA.adj());
00411   }
00412   xA = xd;
00413   yC = yd;
00414   fA = operator*(xA,yC);
00415   A::Gradcomp();
00416   if (differ(fA.val(), f)) botch("fA = operator*(xA,yC)", f, fA.val());
00417   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yC)/dx", dx, xA.adj());
00418   else if (differ(yC.adj(), dy)) botch("d operator*(xA,yC)/dy", dy, yC.adj());
00419   {
00420   A::aval_reset();
00421   cA xcA(xd);
00422   yC = yd;
00423   fA = operator*(xcA,yC);
00424   A::Gradcomp();
00425   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yC)", f, fA.val());
00426   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yC)/dx", dx, xcA.adj());
00427   else if (differ(yC.adj(), dy)) botch("d operator*(xcA,yC)/dy", dy, yC.adj());
00428   }
00429   {
00430   A::aval_reset();
00431   xA = xd;
00432   cC ycC(yd);
00433   fA = operator*(xA,ycC);
00434   A::Gradcomp();
00435   if (differ(fA.val(), f)) botch("fA = operator*(xA,ycC)", f, fA.val());
00436   else if (differ(xA.adj(), dx)) botch("d operator*(xA,ycC)/dx", dx, xA.adj());
00437   else if (differ(ycC.adj(), dy)) botch("d operator*(xA,ycC)/dy", dy, ycC.adj());
00438   }
00439   {
00440   A::aval_reset();
00441   cA xcA(xd);
00442   cC ycC(yd);
00443   fA = operator*(xcA,ycC);
00444   A::Gradcomp();
00445   if (differ(fA.val(), f)) botch("fA = operator*(xcA,ycC)", f, fA.val());
00446   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,ycC)/dx", dx, xcA.adj());
00447   else if (differ(ycC.adj(), dy)) botch("d operator*(xcA,ycC)/dy", dy, ycC.adj());
00448   }
00449   {
00450   xA = xd;
00451   Ai yAi(yd);
00452   fA = operator*(xA,yAi);
00453   A::Gradcomp();
00454   if (differ(fA.val(), f)) botch("fA = operator*(xA,yAi)", f, fA.val());
00455   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yAi)/dx", dx, xA.adj());
00456   else if (differ(yAi.aval, dy)) botch("d operator*(xA,yAi)/dy", dy, yAi.aval);
00457   }
00458   {
00459   A::aval_reset();
00460   cA xcA(xd);
00461   Ai yAi(yd);
00462   fA = operator*(xcA,yAi);
00463   A::Gradcomp();
00464   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yAi)", f, fA.val());
00465   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yAi)/dx", dx, xcA.adj());
00466   else if (differ(yAi.aval, dy)) botch("d operator*(xcA,yAi)/dy", dy, yAi.aval);
00467   }
00468   {
00469   A::aval_reset();
00470   xA = xd;
00471   cAi ycAi(yd);
00472   fA = operator*(xA,ycAi);
00473   A::Gradcomp();
00474   if (differ(fA.val(), f)) botch("fA = operator*(xA,ycAi)", f, fA.val());
00475   else if (differ(xA.adj(), dx)) botch("d operator*(xA,ycAi)/dx", dx, xA.adj());
00476   else if (differ(ycAi.aval, dy)) botch("d operator*(xA,ycAi)/dy", dy, ycAi.aval);
00477   }
00478   {
00479   A::aval_reset();
00480   cA xcA(xd);
00481   cAi ycAi(yd);
00482   fA = operator*(xcA,ycAi);
00483   A::Gradcomp();
00484   if (differ(fA.val(), f)) botch("fA = operator*(xcA,ycAi)", f, fA.val());
00485   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,ycAi)/dx", dx, xcA.adj());
00486   else if (differ(ycAi.aval, dy)) botch("d operator*(xcA,ycAi)/dy", dy, ycAi.aval);
00487   }
00488   xA = xd;
00489   fA = operator*(xA,yd);
00490   A::Gradcomp();
00491   if (differ(fA.val(), f)) botch("fA = operator*(xA,yd)", f, fA.val());
00492   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yd)/dx", dx, xA.adj());
00493   {
00494   A::aval_reset();
00495   cA xcA(xd);
00496   fA = operator*(xcA,yd);
00497   A::Gradcomp();
00498   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yd)", f, fA.val());
00499   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yd)/dx", dx, xcA.adj());
00500   }
00501   xA = xd;
00502   yL = (long)yd;
00503   fA = operator*(xA,yL);
00504   A::Gradcomp();
00505   if (differ(fA.val(), f)) botch("fA = operator*(xA,yL)", f, fA.val());
00506   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yL)/dx", dx, xA.adj());
00507   {
00508   A::aval_reset();
00509   cA xcA(xd);
00510   yL = (long)yd;
00511   fA = operator*(xcA,yL);
00512   A::Gradcomp();
00513   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yL)", f, fA.val());
00514   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yL)/dx", dx, xcA.adj());
00515   }
00516   xA = xd;
00517   yi = (int)yd;
00518   fA = operator*(xA,yi);
00519   A::Gradcomp();
00520   if (differ(fA.val(), f)) botch("fA = operator*(xA,yi)", f, fA.val());
00521   else if (differ(xA.adj(), dx)) botch("d operator*(xA,yi)/dx", dx, xA.adj());
00522   {
00523   A::aval_reset();
00524   cA xcA(xd);
00525   yi = (int)yd;
00526   fA = operator*(xcA,yi);
00527   A::Gradcomp();
00528   if (differ(fA.val(), f)) botch("fA = operator*(xcA,yi)", f, fA.val());
00529   else if (differ(xcA.adj(), dx)) botch("d operator*(xcA,yi)/dx", dx, xcA.adj());
00530   }
00531   xC = xd;
00532   yAI = yd;
00533   fA = operator*(xC,yAI);
00534   A::Gradcomp();
00535   if (differ(fA.val(), f)) botch("fA = operator*(xC,yAI)", f, fA.val());
00536   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yAI)/dx", dx, xC.adj());
00537   else if (differ(yAI.adj(), dy)) botch("d operator*(xC,yAI)/dy", dy, yAI.adj());
00538   {
00539   A::aval_reset();
00540   cC xcC(xd);
00541   yAI = yd;
00542   fA = operator*(xcC,yAI);
00543   A::Gradcomp();
00544   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yAI)", f, fA.val());
00545   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yAI)/dx", dx, xcC.adj());
00546   else if (differ(yAI.adj(), dy)) botch("d operator*(xcC,yAI)/dy", dy, yAI.adj());
00547   }
00548   {
00549   A::aval_reset();
00550   xC = xd;
00551   cAI ycAI(yd);
00552   fA = operator*(xC,ycAI);
00553   A::Gradcomp();
00554   if (differ(fA.val(), f)) botch("fA = operator*(xC,ycAI)", f, fA.val());
00555   else if (differ(xC.adj(), dx)) botch("d operator*(xC,ycAI)/dx", dx, xC.adj());
00556   else if (differ(ycAI.adj(), dy)) botch("d operator*(xC,ycAI)/dy", dy, ycAI.adj());
00557   }
00558   {
00559   A::aval_reset();
00560   cC xcC(xd);
00561   cAI ycAI(yd);
00562   fA = operator*(xcC,ycAI);
00563   A::Gradcomp();
00564   if (differ(fA.val(), f)) botch("fA = operator*(xcC,ycAI)", f, fA.val());
00565   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,ycAI)/dx", dx, xcC.adj());
00566   else if (differ(ycAI.adj(), dy)) botch("d operator*(xcC,ycAI)/dy", dy, ycAI.adj());
00567   }
00568   xC = xd;
00569   yA = yd;
00570   fA = operator*(xC,yA);
00571   A::Gradcomp();
00572   if (differ(fA.val(), f)) botch("fA = operator*(xC,yA)", f, fA.val());
00573   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yA)/dx", dx, xC.adj());
00574   else if (differ(yA.adj(), dy)) botch("d operator*(xC,yA)/dy", dy, yA.adj());
00575   {
00576   A::aval_reset();
00577   cC xcC(xd);
00578   yA = yd;
00579   fA = operator*(xcC,yA);
00580   A::Gradcomp();
00581   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yA)", f, fA.val());
00582   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yA)/dx", dx, xcC.adj());
00583   else if (differ(yA.adj(), dy)) botch("d operator*(xcC,yA)/dy", dy, yA.adj());
00584   }
00585   {
00586   A::aval_reset();
00587   xC = xd;
00588   cA ycA(yd);
00589   fA = operator*(xC,ycA);
00590   A::Gradcomp();
00591   if (differ(fA.val(), f)) botch("fA = operator*(xC,ycA)", f, fA.val());
00592   else if (differ(xC.adj(), dx)) botch("d operator*(xC,ycA)/dx", dx, xC.adj());
00593   else if (differ(ycA.adj(), dy)) botch("d operator*(xC,ycA)/dy", dy, ycA.adj());
00594   }
00595   {
00596   A::aval_reset();
00597   cC xcC(xd);
00598   cA ycA(yd);
00599   fA = operator*(xcC,ycA);
00600   A::Gradcomp();
00601   if (differ(fA.val(), f)) botch("fA = operator*(xcC,ycA)", f, fA.val());
00602   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,ycA)/dx", dx, xcC.adj());
00603   else if (differ(ycA.adj(), dy)) botch("d operator*(xcC,ycA)/dy", dy, ycA.adj());
00604   }
00605   xC = xd;
00606   yC = yd;
00607   fA = operator*(xC,yC);
00608   A::Gradcomp();
00609   if (differ(fA.val(), f)) botch("fA = operator*(xC,yC)", f, fA.val());
00610   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yC)/dx", dx, xC.adj());
00611   else if (differ(yC.adj(), dy)) botch("d operator*(xC,yC)/dy", dy, yC.adj());
00612   {
00613   A::aval_reset();
00614   cC xcC(xd);
00615   yC = yd;
00616   fA = operator*(xcC,yC);
00617   A::Gradcomp();
00618   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yC)", f, fA.val());
00619   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yC)/dx", dx, xcC.adj());
00620   else if (differ(yC.adj(), dy)) botch("d operator*(xcC,yC)/dy", dy, yC.adj());
00621   }
00622   {
00623   A::aval_reset();
00624   xC = xd;
00625   cC ycC(yd);
00626   fA = operator*(xC,ycC);
00627   A::Gradcomp();
00628   if (differ(fA.val(), f)) botch("fA = operator*(xC,ycC)", f, fA.val());
00629   else if (differ(xC.adj(), dx)) botch("d operator*(xC,ycC)/dx", dx, xC.adj());
00630   else if (differ(ycC.adj(), dy)) botch("d operator*(xC,ycC)/dy", dy, ycC.adj());
00631   }
00632   {
00633   A::aval_reset();
00634   cC xcC(xd);
00635   cC ycC(yd);
00636   fA = operator*(xcC,ycC);
00637   A::Gradcomp();
00638   if (differ(fA.val(), f)) botch("fA = operator*(xcC,ycC)", f, fA.val());
00639   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,ycC)/dx", dx, xcC.adj());
00640   else if (differ(ycC.adj(), dy)) botch("d operator*(xcC,ycC)/dy", dy, ycC.adj());
00641   }
00642   {
00643   xC = xd;
00644   Ai yAi(yd);
00645   fA = operator*(xC,yAi);
00646   A::Gradcomp();
00647   if (differ(fA.val(), f)) botch("fA = operator*(xC,yAi)", f, fA.val());
00648   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yAi)/dx", dx, xC.adj());
00649   else if (differ(yAi.aval, dy)) botch("d operator*(xC,yAi)/dy", dy, yAi.aval);
00650   }
00651   {
00652   A::aval_reset();
00653   cC xcC(xd);
00654   Ai yAi(yd);
00655   fA = operator*(xcC,yAi);
00656   A::Gradcomp();
00657   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yAi)", f, fA.val());
00658   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yAi)/dx", dx, xcC.adj());
00659   else if (differ(yAi.aval, dy)) botch("d operator*(xcC,yAi)/dy", dy, yAi.aval);
00660   }
00661   {
00662   A::aval_reset();
00663   xC = xd;
00664   cAi ycAi(yd);
00665   fA = operator*(xC,ycAi);
00666   A::Gradcomp();
00667   if (differ(fA.val(), f)) botch("fA = operator*(xC,ycAi)", f, fA.val());
00668   else if (differ(xC.adj(), dx)) botch("d operator*(xC,ycAi)/dx", dx, xC.adj());
00669   else if (differ(ycAi.aval, dy)) botch("d operator*(xC,ycAi)/dy", dy, ycAi.aval);
00670   }
00671   {
00672   A::aval_reset();
00673   cC xcC(xd);
00674   cAi ycAi(yd);
00675   fA = operator*(xcC,ycAi);
00676   A::Gradcomp();
00677   if (differ(fA.val(), f)) botch("fA = operator*(xcC,ycAi)", f, fA.val());
00678   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,ycAi)/dx", dx, xcC.adj());
00679   else if (differ(ycAi.aval, dy)) botch("d operator*(xcC,ycAi)/dy", dy, ycAi.aval);
00680   }
00681   xC = xd;
00682   fA = operator*(xC,yd);
00683   A::Gradcomp();
00684   if (differ(fA.val(), f)) botch("fA = operator*(xC,yd)", f, fA.val());
00685   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yd)/dx", dx, xC.adj());
00686   {
00687   A::aval_reset();
00688   cC xcC(xd);
00689   fA = operator*(xcC,yd);
00690   A::Gradcomp();
00691   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yd)", f, fA.val());
00692   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yd)/dx", dx, xcC.adj());
00693   }
00694   xC = xd;
00695   yL = (long)yd;
00696   fA = operator*(xC,yL);
00697   A::Gradcomp();
00698   if (differ(fA.val(), f)) botch("fA = operator*(xC,yL)", f, fA.val());
00699   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yL)/dx", dx, xC.adj());
00700   {
00701   A::aval_reset();
00702   cC xcC(xd);
00703   yL = (long)yd;
00704   fA = operator*(xcC,yL);
00705   A::Gradcomp();
00706   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yL)", f, fA.val());
00707   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yL)/dx", dx, xcC.adj());
00708   }
00709   xC = xd;
00710   yi = (int)yd;
00711   fA = operator*(xC,yi);
00712   A::Gradcomp();
00713   if (differ(fA.val(), f)) botch("fA = operator*(xC,yi)", f, fA.val());
00714   else if (differ(xC.adj(), dx)) botch("d operator*(xC,yi)/dx", dx, xC.adj());
00715   {
00716   A::aval_reset();
00717   cC xcC(xd);
00718   yi = (int)yd;
00719   fA = operator*(xcC,yi);
00720   A::Gradcomp();
00721   if (differ(fA.val(), f)) botch("fA = operator*(xcC,yi)", f, fA.val());
00722   else if (differ(xcC.adj(), dx)) botch("d operator*(xcC,yi)/dx", dx, xcC.adj());
00723   }
00724   {
00725   Ai xAi(xd);
00726   yAI = yd;
00727   fA = operator*(xAi,yAI);
00728   A::Gradcomp();
00729   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yAI)", f, fA.val());
00730   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yAI)/dx", dx, xAi.aval);
00731   else if (differ(yAI.adj(), dy)) botch("d operator*(xAi,yAI)/dy", dy, yAI.adj());
00732   }
00733   {
00734   A::aval_reset();
00735   cAi xcAi(xd);
00736   yAI = yd;
00737   fA = operator*(xcAi,yAI);
00738   A::Gradcomp();
00739   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yAI)", f, fA.val());
00740   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yAI)/dx", dx, xcAi.aval);
00741   else if (differ(yAI.adj(), dy)) botch("d operator*(xcAi,yAI)/dy", dy, yAI.adj());
00742   }
00743   {
00744   A::aval_reset();
00745   Ai xAi(xd);
00746   cAI ycAI(yd);
00747   fA = operator*(xAi,ycAI);
00748   A::Gradcomp();
00749   if (differ(fA.val(), f)) botch("fA = operator*(xAi,ycAI)", f, fA.val());
00750   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,ycAI)/dx", dx, xAi.aval);
00751   else if (differ(ycAI.adj(), dy)) botch("d operator*(xAi,ycAI)/dy", dy, ycAI.adj());
00752   }
00753   {
00754   Ai xAi(xd);
00755   yA = yd;
00756   fA = operator*(xAi,yA);
00757   A::Gradcomp();
00758   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yA)", f, fA.val());
00759   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yA)/dx", dx, xAi.aval);
00760   else if (differ(yA.adj(), dy)) botch("d operator*(xAi,yA)/dy", dy, yA.adj());
00761   }
00762   {
00763   A::aval_reset();
00764   cAi xcAi(xd);
00765   yA = yd;
00766   fA = operator*(xcAi,yA);
00767   A::Gradcomp();
00768   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yA)", f, fA.val());
00769   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yA)/dx", dx, xcAi.aval);
00770   else if (differ(yA.adj(), dy)) botch("d operator*(xcAi,yA)/dy", dy, yA.adj());
00771   }
00772   {
00773   A::aval_reset();
00774   Ai xAi(xd);
00775   cA ycA(yd);
00776   fA = operator*(xAi,ycA);
00777   A::Gradcomp();
00778   if (differ(fA.val(), f)) botch("fA = operator*(xAi,ycA)", f, fA.val());
00779   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,ycA)/dx", dx, xAi.aval);
00780   else if (differ(ycA.adj(), dy)) botch("d operator*(xAi,ycA)/dy", dy, ycA.adj());
00781   }
00782   {
00783   Ai xAi(xd);
00784   yC = yd;
00785   fA = operator*(xAi,yC);
00786   A::Gradcomp();
00787   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yC)", f, fA.val());
00788   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yC)/dx", dx, xAi.aval);
00789   else if (differ(yC.adj(), dy)) botch("d operator*(xAi,yC)/dy", dy, yC.adj());
00790   }
00791   {
00792   A::aval_reset();
00793   cAi xcAi(xd);
00794   yC = yd;
00795   fA = operator*(xcAi,yC);
00796   A::Gradcomp();
00797   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yC)", f, fA.val());
00798   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yC)/dx", dx, xcAi.aval);
00799   else if (differ(yC.adj(), dy)) botch("d operator*(xcAi,yC)/dy", dy, yC.adj());
00800   }
00801   {
00802   A::aval_reset();
00803   Ai xAi(xd);
00804   cC ycC(yd);
00805   fA = operator*(xAi,ycC);
00806   A::Gradcomp();
00807   if (differ(fA.val(), f)) botch("fA = operator*(xAi,ycC)", f, fA.val());
00808   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,ycC)/dx", dx, xAi.aval);
00809   else if (differ(ycC.adj(), dy)) botch("d operator*(xAi,ycC)/dy", dy, ycC.adj());
00810   }
00811   {
00812   Ai xAi(xd);
00813   Ai yAi(yd);
00814   fA = operator*(xAi,yAi);
00815   A::Gradcomp();
00816   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yAi)", f, fA.val());
00817   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yAi)/dx", dx, xAi.aval);
00818   else if (differ(yAi.aval, dy)) botch("d operator*(xAi,yAi)/dy", dy, yAi.aval);
00819   }
00820   {
00821   A::aval_reset();
00822   cAi xcAi(xd);
00823   Ai yAi(yd);
00824   fA = operator*(xcAi,yAi);
00825   A::Gradcomp();
00826   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yAi)", f, fA.val());
00827   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yAi)/dx", dx, xcAi.aval);
00828   else if (differ(yAi.aval, dy)) botch("d operator*(xcAi,yAi)/dy", dy, yAi.aval);
00829   }
00830   {
00831   A::aval_reset();
00832   Ai xAi(xd);
00833   cAi ycAi(yd);
00834   fA = operator*(xAi,ycAi);
00835   A::Gradcomp();
00836   if (differ(fA.val(), f)) botch("fA = operator*(xAi,ycAi)", f, fA.val());
00837   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,ycAi)/dx", dx, xAi.aval);
00838   else if (differ(ycAi.aval, dy)) botch("d operator*(xAi,ycAi)/dy", dy, ycAi.aval);
00839   }
00840   {
00841   Ai xAi(xd);
00842   fA = operator*(xAi,yd);
00843   A::Gradcomp();
00844   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yd)", f, fA.val());
00845   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yd)/dx", dx, xAi.aval);
00846   }
00847   {
00848   A::aval_reset();
00849   cAi xcAi(xd);
00850   fA = operator*(xcAi,yd);
00851   A::Gradcomp();
00852   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yd)", f, fA.val());
00853   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yd)/dx", dx, xcAi.aval);
00854   }
00855   {
00856   Ai xAi(xd);
00857   yL = (long)yd;
00858   fA = operator*(xAi,yL);
00859   A::Gradcomp();
00860   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yL)", f, fA.val());
00861   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yL)/dx", dx, xAi.aval);
00862   }
00863   {
00864   A::aval_reset();
00865   cAi xcAi(xd);
00866   yL = (long)yd;
00867   fA = operator*(xcAi,yL);
00868   A::Gradcomp();
00869   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yL)", f, fA.val());
00870   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yL)/dx", dx, xcAi.aval);
00871   }
00872   {
00873   Ai xAi(xd);
00874   yi = (int)yd;
00875   fA = operator*(xAi,yi);
00876   A::Gradcomp();
00877   if (differ(fA.val(), f)) botch("fA = operator*(xAi,yi)", f, fA.val());
00878   else if (differ(xAi.aval, dx)) botch("d operator*(xAi,yi)/dx", dx, xAi.aval);
00879   }
00880   {
00881   A::aval_reset();
00882   cAi xcAi(xd);
00883   yi = (int)yd;
00884   fA = operator*(xcAi,yi);
00885   A::Gradcomp();
00886   if (differ(fA.val(), f)) botch("fA = operator*(xcAi,yi)", f, fA.val());
00887   else if (differ(xcAi.aval, dx)) botch("d operator*(xcAi,yi)/dx", dx, xcAi.aval);
00888   }
00889   yAI = yd;
00890   fA = operator*(xd,yAI);
00891   A::Gradcomp();
00892   if (differ(fA.val(), f)) botch("fA = operator*(xd,yAI)", f, fA.val());
00893   else if (differ(yAI.adj(), dy)) botch("d operator*(xd,yAI)/dy", dy, yAI.adj());
00894   {
00895   A::aval_reset();
00896   cAI ycAI(yd);
00897   fA = operator*(xd,ycAI);
00898   A::Gradcomp();
00899   if (differ(fA.val(), f)) botch("fA = operator*(xd,ycAI)", f, fA.val());
00900   else if (differ(ycAI.adj(), dy)) botch("d operator*(xd,ycAI)/dy", dy, ycAI.adj());
00901   }
00902   yA = yd;
00903   fA = operator*(xd,yA);
00904   A::Gradcomp();
00905   if (differ(fA.val(), f)) botch("fA = operator*(xd,yA)", f, fA.val());
00906   else if (differ(yA.adj(), dy)) botch("d operator*(xd,yA)/dy", dy, yA.adj());
00907   {
00908   A::aval_reset();
00909   cA ycA(yd);
00910   fA = operator*(xd,ycA);
00911   A::Gradcomp();
00912   if (differ(fA.val(), f)) botch("fA = operator*(xd,ycA)", f, fA.val());
00913   else if (differ(ycA.adj(), dy)) botch("d operator*(xd,ycA)/dy", dy, ycA.adj());
00914   }
00915   yC = yd;
00916   fA = operator*(xd,yC);
00917   A::Gradcomp();
00918   if (differ(fA.val(), f)) botch("fA = operator*(xd,yC)", f, fA.val());
00919   else if (differ(yC.adj(), dy)) botch("d operator*(xd,yC)/dy", dy, yC.adj());
00920   {
00921   A::aval_reset();
00922   cC ycC(yd);
00923   fA = operator*(xd,ycC);
00924   A::Gradcomp();
00925   if (differ(fA.val(), f)) botch("fA = operator*(xd,ycC)", f, fA.val());
00926   else if (differ(ycC.adj(), dy)) botch("d operator*(xd,ycC)/dy", dy, ycC.adj());
00927   }
00928   {
00929   Ai yAi(yd);
00930   fA = operator*(xd,yAi);
00931   A::Gradcomp();
00932   if (differ(fA.val(), f)) botch("fA = operator*(xd,yAi)", f, fA.val());
00933   else if (differ(yAi.aval, dy)) botch("d operator*(xd,yAi)/dy", dy, yAi.aval);
00934   }
00935   {
00936   A::aval_reset();
00937   cAi ycAi(yd);
00938   fA = operator*(xd,ycAi);
00939   A::Gradcomp();
00940   if (differ(fA.val(), f)) botch("fA = operator*(xd,ycAi)", f, fA.val());
00941   else if (differ(ycAi.aval, dy)) botch("d operator*(xd,ycAi)/dy", dy, ycAi.aval);
00942   }
00943   xL = (long)xd;
00944   yAI = yd;
00945   fA = operator*(xL,yAI);
00946   A::Gradcomp();
00947   if (differ(fA.val(), f)) botch("fA = operator*(xL,yAI)", f, fA.val());
00948   else if (differ(yAI.adj(), dy)) botch("d operator*(xL,yAI)/dy", dy, yAI.adj());
00949   {
00950   A::aval_reset();
00951   xL = (long)xd;
00952   cAI ycAI(yd);
00953   fA = operator*(xL,ycAI);
00954   A::Gradcomp();
00955   if (differ(fA.val(), f)) botch("fA = operator*(xL,ycAI)", f, fA.val());
00956   else if (differ(ycAI.adj(), dy)) botch("d operator*(xL,ycAI)/dy", dy, ycAI.adj());
00957   }
00958   xL = (long)xd;
00959   yA = yd;
00960   fA = operator*(xL,yA);
00961   A::Gradcomp();
00962   if (differ(fA.val(), f)) botch("fA = operator*(xL,yA)", f, fA.val());
00963   else if (differ(yA.adj(), dy)) botch("d operator*(xL,yA)/dy", dy, yA.adj());
00964   {
00965   A::aval_reset();
00966   xL = (long)xd;
00967   cA ycA(yd);
00968   fA = operator*(xL,ycA);
00969   A::Gradcomp();
00970   if (differ(fA.val(), f)) botch("fA = operator*(xL,ycA)", f, fA.val());
00971   else if (differ(ycA.adj(), dy)) botch("d operator*(xL,ycA)/dy", dy, ycA.adj());
00972   }
00973   xL = (long)xd;
00974   yC = yd;
00975   fA = operator*(xL,yC);
00976   A::Gradcomp();
00977   if (differ(fA.val(), f)) botch("fA = operator*(xL,yC)", f, fA.val());
00978   else if (differ(yC.adj(), dy)) botch("d operator*(xL,yC)/dy", dy, yC.adj());
00979   {
00980   A::aval_reset();
00981   xL = (long)xd;
00982   cC ycC(yd);
00983   fA = operator*(xL,ycC);
00984   A::Gradcomp();
00985   if (differ(fA.val(), f)) botch("fA = operator*(xL,ycC)", f, fA.val());
00986   else if (differ(ycC.adj(), dy)) botch("d operator*(xL,ycC)/dy", dy, ycC.adj());
00987   }
00988   {
00989   xL = (long)xd;
00990   Ai yAi(yd);
00991   fA = operator*(xL,yAi);
00992   A::Gradcomp();
00993   if (differ(fA.val(), f)) botch("fA = operator*(xL,yAi)", f, fA.val());
00994   else if (differ(yAi.aval, dy)) botch("d operator*(xL,yAi)/dy", dy, yAi.aval);
00995   }
00996   {
00997   A::aval_reset();
00998   xL = (long)xd;
00999   cAi ycAi(yd);
01000   fA = operator*(xL,ycAi);
01001   A::Gradcomp();
01002   if (differ(fA.val(), f)) botch("fA = operator*(xL,ycAi)", f, fA.val());
01003   else if (differ(ycAi.aval, dy)) botch("d operator*(xL,ycAi)/dy", dy, ycAi.aval);
01004   }
01005   xi = (int)xd;
01006   yAI = yd;
01007   fA = operator*(xi,yAI);
01008   A::Gradcomp();
01009   if (differ(fA.val(), f)) botch("fA = operator*(xi,yAI)", f, fA.val());
01010   else if (differ(yAI.adj(), dy)) botch("d operator*(xi,yAI)/dy", dy, yAI.adj());
01011   {
01012   A::aval_reset();
01013   xi = (int)xd;
01014   cAI ycAI(yd);
01015   fA = operator*(xi,ycAI);
01016   A::Gradcomp();
01017   if (differ(fA.val(), f)) botch("fA = operator*(xi,ycAI)", f, fA.val());
01018   else if (differ(ycAI.adj(), dy)) botch("d operator*(xi,ycAI)/dy", dy, ycAI.adj());
01019   }
01020   xi = (int)xd;
01021   yA = yd;
01022   fA = operator*(xi,yA);
01023   A::Gradcomp();
01024   if (differ(fA.val(), f)) botch("fA = operator*(xi,yA)", f, fA.val());
01025   else if (differ(yA.adj(), dy)) botch("d operator*(xi,yA)/dy", dy, yA.adj());
01026   {
01027   A::aval_reset();
01028   xi = (int)xd;
01029   cA ycA(yd);
01030   fA = operator*(xi,ycA);
01031   A::Gradcomp();
01032   if (differ(fA.val(), f)) botch("fA = operator*(xi,ycA)", f, fA.val());
01033   else if (differ(ycA.adj(), dy)) botch("d operator*(xi,ycA)/dy", dy, ycA.adj());
01034   }
01035   xi = (int)xd;
01036   yC = yd;
01037   fA = operator*(xi,yC);
01038   A::Gradcomp();
01039   if (differ(fA.val(), f)) botch("fA = operator*(xi,yC)", f, fA.val());
01040   else if (differ(yC.adj(), dy)) botch("d operator*(xi,yC)/dy", dy, yC.adj());
01041   {
01042   A::aval_reset();
01043   xi = (int)xd;
01044   cC ycC(yd);
01045   fA = operator*(xi,ycC);
01046   A::Gradcomp();
01047   if (differ(fA.val(), f)) botch("fA = operator*(xi,ycC)", f, fA.val());
01048   else if (differ(ycC.adj(), dy)) botch("d operator*(xi,ycC)/dy", dy, ycC.adj());
01049   }
01050   {
01051   xi = (int)xd;
01052   Ai yAi(yd);
01053   fA = operator*(xi,yAi);
01054   A::Gradcomp();
01055   if (differ(fA.val(), f)) botch("fA = operator*(xi,yAi)", f, fA.val());
01056   else if (differ(yAi.aval, dy)) botch("d operator*(xi,yAi)/dy", dy, yAi.aval);
01057   }
01058   {
01059   A::aval_reset();
01060   xi = (int)xd;
01061   cAi ycAi(yd);
01062   fA = operator*(xi,ycAi);
01063   A::Gradcomp();
01064   if (differ(fA.val(), f)) botch("fA = operator*(xi,ycAi)", f, fA.val());
01065   else if (differ(ycAi.aval, dy)) botch("d operator*(xi,ycAi)/dy", dy, ycAi.aval);
01066   }
01067 
01068 
01069   if (!rc) // chatter for cppunit test, which cannot tolerate silence
01070 
01071     printf("OK\n");
01072 
01073   return rc;
01074 
01075   }