Code-Eli  0.3.6
ad_dual_test_suite.hpp
Go to the documentation of this file.
1 /*********************************************************************************
2 * Copyright (c) 2013 David D. Marshall <ddmarsha@calpoly.edu>
3 *
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * David D. Marshall - initial code and implementation
11 ********************************************************************************/
12 
13 #ifndef ad_dual_test_suite_hpp
14 #define ad_dual_test_suite_hpp
15 
16 #include <cmath> // std::pow, std::exp
17 
18 #include <typeinfo> // typeid
19 #include <string> // std::string
20 #include <sstream> // std::stringstream
21 #include <iomanip> // std::setw
22 #include <limits> // std::numeric_limits
23 
24 #include "eli/constants/math.hpp"
25 #include "eli/mutil/ad/dual.hpp"
26 
27 template<typename data__>
28 class ad_dual_test_suite : public Test::Suite
29 {
30  protected:
31  void AddTests(const float &)
32  {
54  }
55 
56  void AddTests(const double &)
57  {
79  }
80 
81  void AddTests(const long double &)
82  {
104  }
105 
106  public:
108  {
109  // add the tests
110  AddTests(data__());
111  }
113  {
114  }
115 
116  private:
118  {
119  eli::mutil::ad::dual<data__, false> d1, d2(1,2), d4(-2,4), d5;
120  data__ v1(2);
121 
122  // test copy ctr
124  TEST_ASSERT(d3.exact(d2));
125 
126  // test constructor with expression
128  d5.set_real(d2.real()+d4.real());
129  d5.set_nonreal(d2.nonreal()+d4.nonreal());
130 
131  // test assignment operator
132  d1=d2;
133  TEST_ASSERT(d1.exact(d2));
134 
135  // test A=v
136  d5.set_real(v1);
137  d5.set_nonreal(0.0);
138  d4=v1;
139  TEST_ASSERT(d4.exact(d5));
140 
141  // test A=int
142  d5.set_real(2);
143  d5.set_nonreal(0.0);
144  d4=2;
145  TEST_ASSERT(d4.exact(d5));
146  }
147 
149  {
150  eli::mutil::ad::dual<data__, false> d1(1,3), d2(1,2), d3(1,2), d4(-2,4), d5(2,4), d6(2,0), d7(1,-3), d8(3,-1);
151  data__ v1(2);
152 
153  // compare dual & dual
154  TEST_ASSERT(d2==d3); // both equal
155  TEST_ASSERT(d1!=d3); // real equal
156  TEST_ASSERT(d4!=d5); // nonreal equal
157  TEST_ASSERT(d1!=d4); // neither equal
158 
159  // compare dual & v
160  TEST_ASSERT(d6==v1); // equal real, zero nonreal
161  TEST_ASSERT(d5!=v1); // equal real, nonzero nonreal
162  TEST_ASSERT(d1!=v1); // neither equal
163  TEST_ASSERT(v1==d6); // equal real, zero nonreal
164  TEST_ASSERT(v1!=d5); // equal real, nonzero nonreal
165  TEST_ASSERT(v1!=d1); // neither equal
166 
167  // compare dual & int
168  TEST_ASSERT(d6==2); // equal real, zero nonreal
169  TEST_ASSERT(d5!=2); // equal real, nonzero nonreal
170  TEST_ASSERT(d1!=2); // neither equal
171  TEST_ASSERT(2==d6); // equal real, zero nonreal
172  TEST_ASSERT(2!=d5); // equal real, nonzero nonreal
173  TEST_ASSERT(2!=d1); // neither equal
174 
175  // compare dual & expression
176  TEST_ASSERT(d5==(d2+d3)); // both equal
177  TEST_ASSERT(d5!=(d1+d3)); // real equal
178  TEST_ASSERT(d4!=(d5+d6)); // nonreal equal
179  TEST_ASSERT(d5!=(d1+d4)); // neither equal
180  TEST_ASSERT((d2+d3)==d5); // both equal
181  TEST_ASSERT((d1+d3)!=d5); // real equal
182  TEST_ASSERT((d5+d6)!=d4); // nonreal equal
183  TEST_ASSERT((d1+d4)!=d5); // neither equal
184 
185  // compare expression & v
186  TEST_ASSERT((d7+d1)==v1); // equal real, zero nonreal
187  TEST_ASSERT((d1+d2)!=v1); // equal real, nonzero nonreal
188  TEST_ASSERT((d1+d4)!=v1); // neither equal
189  TEST_ASSERT(v1==(d7+d1)); // equal real, zero nonreal
190  TEST_ASSERT(v1!=(d1+d2)); // equal real, nonzero nonreal
191  TEST_ASSERT(v1!=(d1+d4)); // neither equal
192 
193  // compare expression & int
194  TEST_ASSERT((d7+d1)==2); // equal real, zero nonreal
195  TEST_ASSERT((d1+d2)!=2); // equal real, nonzero nonreal
196  TEST_ASSERT((d1+d4)!=2); // neither equal
197  TEST_ASSERT(2==(d7+d1)); // equal real, zero nonreal
198  TEST_ASSERT(2!=(d1+d2)); // equal real, nonzero nonreal
199  TEST_ASSERT(2!=(d1+d4)); // neither equal
200 
201  // compare expression & expression
202  TEST_ASSERT((d2+d3)==(d2+d3)); // both equal
203  TEST_ASSERT((d2+d3)!=(d1+d3)); // real equal
204  TEST_ASSERT((d4+d6)!=(d5+d6)); // nonreal equal
205  TEST_ASSERT((d1+d5)!=(d1+d4)); // neither equal
206 
207  // TODO: DO NOT KNOW HOW TO DO GREATER/LESS THAN WITH EXACT COMPARISONS
208  }
209 
211  {
212  eli::mutil::ad::dual<data__, true> d1(1,3), d2(1,2), d3(1,2), d4(-2,4), d5(2,4), d6(2,0), d7(1,-3), d8(3,-1);
213  data__ v1(2);
214 
215  // compare dual & dual
216  TEST_ASSERT(d2==d3); // both equal
217  TEST_ASSERT(d1==d3); // real equal
218  TEST_ASSERT(d4!=d5); // nonreal equal
219  TEST_ASSERT(d1!=d4); // neither equal
220 
221  // compare dual & v
222  TEST_ASSERT(d6==v1); // equal real, zero nonreal
223  TEST_ASSERT(d5==v1); // equal real, nonzero nonreal
224  TEST_ASSERT(d1!=v1); // neither equal
225  TEST_ASSERT(v1==d6); // equal real, zero nonreal
226  TEST_ASSERT(v1==d5); // equal real, nonzero nonreal
227  TEST_ASSERT(v1!=d1); // neither equal
228 
229  // compare dual & int
230  TEST_ASSERT(d6==2); // equal real, zero nonreal
231  TEST_ASSERT(d5==2); // equal real, nonzero nonreal
232  TEST_ASSERT(d1!=2); // neither equal
233  TEST_ASSERT(2==d6); // equal real, zero nonreal
234  TEST_ASSERT(2==d5); // equal real, nonzero nonreal
235  TEST_ASSERT(2!=d1); // neither equal
236 
237  // compare dual & expression
238  TEST_ASSERT(d5==(d2+d3)); // both equal
239  TEST_ASSERT(d5==(d1+d3)); // real equal
240  TEST_ASSERT(d4!=(d5+d6)); // nonreal equal
241  TEST_ASSERT(d5!=(d1+d4)); // neither equal
242  TEST_ASSERT((d2+d3)==d5); // both equal
243  TEST_ASSERT((d1+d3)==d5); // real equal
244  TEST_ASSERT((d5+d6)!=d4); // nonreal equal
245  TEST_ASSERT((d1+d4)!=d5); // neither equal
246 
247  // compare expression & v
248  TEST_ASSERT((d7+d1)==v1); // equal real, zero nonreal
249  TEST_ASSERT((d1+d2)==v1); // equal real, nonzero nonreal
250  TEST_ASSERT((d1+d4)!=v1); // neither equal
251  TEST_ASSERT(v1==(d7+d1)); // equal real, zero nonreal
252  TEST_ASSERT(v1==(d1+d2)); // equal real, nonzero nonreal
253  TEST_ASSERT(v1!=(d1+d4)); // neither equal
254 
255  // compare expression & INT
256  TEST_ASSERT((d7+d1)==2); // equal real, zero nonreal
257  TEST_ASSERT((d1+d2)==2); // equal real, nonzero nonreal
258  TEST_ASSERT((d1+d4)!=2); // neither equal
259  TEST_ASSERT(2==(d7+d1)); // equal real, zero nonreal
260  TEST_ASSERT(2==(d1+d2)); // equal real, nonzero nonreal
261  TEST_ASSERT(2!=(d1+d4)); // neither equal
262 
263  // compare expression & expression
264  TEST_ASSERT((d2+d3)==(d2+d3)); // both equal
265  TEST_ASSERT((d2+d3)==(d1+d3)); // real equal
266  TEST_ASSERT((d4+d6)!=(d5+d6)); // nonreal equal
267  TEST_ASSERT((d1+d5)!=(d1+d4)); // neither equal
268 
269  // compare dual & dual
270  TEST_ASSERT(d2<=d3); // both equal
271  TEST_ASSERT(d1<=d3); // real equal
272  TEST_ASSERT(d4<=d5); // nonreal equal
273  TEST_ASSERT(d4<=d1); // neither equal
274 
275  // compare dual & v
276  TEST_ASSERT(d6<=v1); // equal real, zero nonreal
277  TEST_ASSERT(d5<=v1); // equal real, nonzero nonreal
278  TEST_ASSERT(d1<=v1); // neither equal
279  TEST_ASSERT(v1<=d6); // equal real, zero nonreal
280  TEST_ASSERT(v1<=d5); // equal real, nonzero nonreal
281  TEST_ASSERT(v1<=d8); // neither equal
282 
283  // compare dual & int
284  TEST_ASSERT(d6<=2); // equal real, zero nonreal
285  TEST_ASSERT(d5<=2); // equal real, nonzero nonreal
286  TEST_ASSERT(d1<=2); // neither equal
287  TEST_ASSERT(2<=d6); // equal real, zero nonreal
288  TEST_ASSERT(2<=d5); // equal real, nonzero nonreal
289  TEST_ASSERT(2<=d8); // neither equal
290 
291  // compare dual & expression
292  TEST_ASSERT(d5<=(d2+d3)); // both equal
293  TEST_ASSERT(d5<=(d1+d3)); // real equal
294  TEST_ASSERT(d4<=(d5+d6)); // nonreal equal
295  TEST_ASSERT(d4<=(d1+d2)); // neither equal
296  TEST_ASSERT((d2+d3)<=d5); // both equal
297  TEST_ASSERT((d1+d3)<=d5); // real equal
298  TEST_ASSERT((d2-d3)<=d6); // nonreal equal
299  TEST_ASSERT((d3+d4)<=d5); // neither equal
300 
301  // compare expression & v
302  TEST_ASSERT((d7+d1)<=v1); // equal real, zero nonreal
303  TEST_ASSERT((d1+d2)<=v1); // equal real, nonzero nonreal
304  TEST_ASSERT((d1+d4)<=v1); // neither equal
305  TEST_ASSERT(v1<=(d7+d1)); // equal real, zero nonreal
306  TEST_ASSERT(v1<=(d1+d2)); // equal real, nonzero nonreal
307  TEST_ASSERT(v1<=(d5+d6)); // neither equal
308 
309  // compare expression & INT
310  TEST_ASSERT((d7+d1)<=2); // equal real, zero nonreal
311  TEST_ASSERT((d1+d2)<=2); // equal real, nonzero nonreal
312  TEST_ASSERT((d1+d4)<=2); // neither equal
313  TEST_ASSERT(2<=(d7+d1)); // equal real, zero nonreal
314  TEST_ASSERT(2<=(d1+d2)); // equal real, nonzero nonreal
315  TEST_ASSERT(2<=(d5+d6)); // neither equal
316 
317  // compare expression & expression
318  TEST_ASSERT((d2+d3)<=(d2+d3)); // both equal
319  TEST_ASSERT((d2+d3)<=(d1+d3)); // real equal
320  TEST_ASSERT((d4+d6)<=(d5+d6)); // nonreal equal
321  TEST_ASSERT((d1+d4)<=(d1+d5)); // neither equal
322 
323  // compare dual & dual
324  TEST_ASSERT(d3>=d2); // both equal
325  TEST_ASSERT(d3>=d1); // real equal
326  TEST_ASSERT(d5>=d4); // nonreal equal
327  TEST_ASSERT(d1>=d4); // neither equal
328 
329  // compare dual & v
330  TEST_ASSERT(d6>=v1); // equal real, zero nonreal
331  TEST_ASSERT(d5>=v1); // equal real, nonzero nonreal
332  TEST_ASSERT(d8>=v1); // neither equal
333  TEST_ASSERT(v1>=d6); // equal real, zero nonreal
334  TEST_ASSERT(v1>=d5); // equal real, nonzero nonreal
335  TEST_ASSERT(v1>=d1); // neither equal
336 
337  // compare dual & int
338  TEST_ASSERT(d6>=2); // equal real, zero nonreal
339  TEST_ASSERT(d5>=2); // equal real, nonzero nonreal
340  TEST_ASSERT(d8>=2); // neither equal
341  TEST_ASSERT(2>=d6); // equal real, zero nonreal
342  TEST_ASSERT(2>=d5); // equal real, nonzero nonreal
343  TEST_ASSERT(2>=d1); // neither equal
344 
345  // compare dual & expression
346  TEST_ASSERT(d5>=(d2+d3)); // both equal
347  TEST_ASSERT(d5>=(d1+d3)); // real equal
348  TEST_ASSERT(d6>=(d2-d3)); // nonreal equal
349  TEST_ASSERT(d5>=(d3+d4)); // neither equal
350  TEST_ASSERT((d2+d3)>=d5); // both equal
351  TEST_ASSERT((d1+d3)>=d5); // real equal
352  TEST_ASSERT((d5+d6)>=d4); // nonreal equal
353  TEST_ASSERT((d1+d2)>=d4); // neither equal
354 
355  // compare expression & v
356  TEST_ASSERT((d7+d1)>=v1); // equal real, zero nonreal
357  TEST_ASSERT((d1+d2)>=v1); // equal real, nonzero nonreal
358  TEST_ASSERT((d5+d6)>=v1); // neither equal
359  TEST_ASSERT(v1>=(d7+d1)); // equal real, zero nonreal
360  TEST_ASSERT(v1>=(d1+d2)); // equal real, nonzero nonreal
361  TEST_ASSERT(v1>=(d1+d4)); // neither equal
362 
363  // compare expression & INT
364  TEST_ASSERT((d7+d1)>=2); // equal real, zero nonreal
365  TEST_ASSERT((d1+d2)>=2); // equal real, nonzero nonreal
366  TEST_ASSERT((d5+d6)>=2); // neither equal
367  TEST_ASSERT(2>=(d7+d1)); // equal real, zero nonreal
368  TEST_ASSERT(2>=(d1+d2)); // equal real, nonzero nonreal
369  TEST_ASSERT(2>=(d1+d4)); // neither equal
370 
371  // compare expression & expression
372  TEST_ASSERT((d2+d3)>=(d2+d3)); // both equal
373  TEST_ASSERT((d2+d3)>=(d1+d3)); // real equal
374  TEST_ASSERT((d5+d6)>=(d4+d6)); // nonreal equal
375  TEST_ASSERT((d1+d5)>=(d1+d4)); // neither equal
376 
377  // compare dual & dual
378  TEST_ASSERT(d4<d5); // nonreal equal
379  TEST_ASSERT(d4<d1); // neither equal
380 
381  // compare dual & v
382  TEST_ASSERT(d1<v1); // neither equal
383  TEST_ASSERT(v1<d8); // neither equal
384 
385  // compare dual & int
386  TEST_ASSERT(d1<2); // neither equal
387  TEST_ASSERT(2<d8); // neither equal
388 
389  // compare dual & expression
390  TEST_ASSERT(d4<(d5+d6)); // nonreal equal
391  TEST_ASSERT(d4<(d1+d2)); // neither equal
392  TEST_ASSERT((d2-d3)<d6); // nonreal equal
393  TEST_ASSERT((d3+d4)<d5); // neither equal
394 
395  // compare expression & v
396  TEST_ASSERT((d1+d4)<v1); // neither equal
397  TEST_ASSERT(v1<(d5+d6)); // neither equal
398 
399  // compare expression & INT
400  TEST_ASSERT((d1+d4)<2); // neither equal
401  TEST_ASSERT(2<(d5+d6)); // neither equal
402 
403  // compare expression & expression
404  TEST_ASSERT((d4+d6)<(d5+d6)); // nonreal equal
405  TEST_ASSERT((d1+d4)<(d1+d5)); // neither equal
406 
407  // compare dual & dual
408  TEST_ASSERT(d5>d4); // nonreal equal
409  TEST_ASSERT(d1>d4); // neither equal
410 
411  // compare dual & v
412  TEST_ASSERT(d8>v1); // neither equal
413  TEST_ASSERT(v1>d1); // neither equal
414 
415  // compare dual & int
416  TEST_ASSERT(d8>2); // neither equal
417  TEST_ASSERT(2>d1); // neither equal
418 
419  // compare dual & expression
420  TEST_ASSERT(d6>(d2-d3)); // nonreal equal
421  TEST_ASSERT(d5>(d3+d4)); // neither equal
422  TEST_ASSERT((d5+d6)>d4); // nonreal equal
423  TEST_ASSERT((d1+d2)>d4); // neither equal
424 
425  // compare expression & v
426  TEST_ASSERT((d5+d6)>v1); // neither equal
427  TEST_ASSERT(v1>(d1+d4)); // neither equal
428 
429  // compare expression & INT
430  TEST_ASSERT((d5+d6)>2); // neither equal
431  TEST_ASSERT(2>(d1+d4)); // neither equal
432 
433  // compare expression & expression
434  TEST_ASSERT((d5+d6)>(d4+d6)); // nonreal equal
435  TEST_ASSERT((d1+d5)>(d1+d4)); // neither equal
436  }
437 
439  {
440  eli::mutil::ad::dual<data__, false> d1(3,-4), d2(1,2), d3(d2), d4, d5;
441  data__ v1(2);
442 
443  // test C=A+B
444  d5.set_real(d2.real()+d3.real());
445  d5.set_nonreal(d2.nonreal()+d3.nonreal());
446  d4=d2+d3;
447  TEST_ASSERT(d4.exact(d5));
448 
449  // test B=A+B
450  d4=d3;
451  d5.set_real(d2.real()+d4.real());
452  d5.set_nonreal(d2.nonreal()+d4.nonreal());
453  d4=d2+d4;
454  TEST_ASSERT(d4.exact(d5));
455 
456  // test B+=A
457  d4=d3;
458  d5.set_real(d2.real()+d4.real());
459  d5.set_nonreal(d2.nonreal()+d4.nonreal());
460  d4+=d2;
461  TEST_ASSERT(d4.exact(d5));
462 
463  // test B+=v
464  d4=d3;
465  d5.set_real(d2.real()+v1);
466  d5.set_nonreal(d2.nonreal()+0);
467  d4+=v1;
468  TEST_ASSERT(d4.exact(d5));
469 
470  // test B+=int
471  d4=d3;
472  d5.set_real(d2.real()+2);
473  d5.set_nonreal(d2.nonreal()+0);
474  d4+=2;
475  TEST_ASSERT(d4.exact(d5));
476 
477  // test C+=A+B
478  d4=d3;
479  d5.set_real(d4.real()+(d1.real()+d2.real()));
480  d5.set_nonreal(d4.nonreal()+(d1.nonreal()+d2.nonreal()));
481  d4+=d1+d2;
482  TEST_ASSERT(d4.exact(d5));
483 
484  // test D=(A+B)+C
485  d5.set_real((d1.real()+d2.real())+d3.real());
486  d5.set_nonreal((d1.nonreal()+d2.nonreal())+d3.nonreal());
487  d4=(d1+d2)+d3;
488  TEST_ASSERT(d4.exact(d5));
489 
490  // test D=A+(B+C)
491  d5.set_real(d1.real()+(d2.real()+d3.real()));
492  d5.set_nonreal(d1.nonreal()+(d2.nonreal()+d3.nonreal()));
493  d4=d1+(d2+d3);
494  TEST_ASSERT(d4.exact(d5));
495 
496  // test D=A+B+C
497  d5.set_real(d1.real()+d2.real()+d3.real());
498  d5.set_nonreal(d1.nonreal()+d2.nonreal()+d3.nonreal());
499  d4=d1+d2+d3;
500  TEST_ASSERT(d4.exact(d5));
501 
502  // test D=(A+B)+(C+C)
503  d5.set_real((d1.real()+d2.real())+(d3.real()+d3.real()));
504  d5.set_nonreal((d1.nonreal()+d2.nonreal())+(d3.nonreal()+d3.nonreal()));
505  d4=(d1+d2)+(d3+d3);
506  TEST_ASSERT(d4.exact(d5));
507 
508  // test C=A+v
509  d5.set_real(d2.real()+v1);
510  d5.set_nonreal(d2.nonreal()+0);
511  d4=d2+v1;
512  TEST_ASSERT(d4.exact(d5));
513 
514  // test C=v+A
515  d5.set_real(v1+d2.real());
516  d5.set_nonreal(0+d2.nonreal());
517  d4=v1+d2;
518  TEST_ASSERT(d4.exact(d5));
519 
520  // test C=A+B+v
521  d5.set_real(d2.real()+d3.real()+v1);
522  d5.set_nonreal(d2.nonreal()+d3.nonreal()+0);
523  d4=d2+d3+v1;
524  TEST_ASSERT(d4.exact(d5));
525 
526  // test C=v+A+B
527  d5.set_real(v1+d2.real()+d3.real());
528  d5.set_nonreal(0+d2.nonreal()+d3.nonreal());
529  d4=v1+d2+d3;
530  TEST_ASSERT(d4.exact(d5));
531 
532  // test C=A+int
533  d5.set_real(d2.real()+2);
534  d5.set_nonreal(d2.nonreal()+0);
535  d4=d2+2;
536  TEST_ASSERT(d4.exact(d5));
537 
538  // test C=int+A
539  d5.set_real(2+d2.real());
540  d5.set_nonreal(d2.nonreal()+0);
541  d4=2+d2;
542  TEST_ASSERT(d4.exact(d5));
543  }
544 
546  {
547  eli::mutil::ad::dual<data__, false> d1(3,-4), d2(1,2), d3(d2), d4, d5;
548  data__ v1(2);
549 
550  // test C=A-B
551  d5.set_real(d2.real()-d3.real());
552  d5.set_nonreal(d2.nonreal()-d3.nonreal());
553  d4=d2-d3;
554  TEST_ASSERT(d4.exact(d5));
555 
556  // test B=A-B
557  d4=d3;
558  d5.set_real(d2.real()-d4.real());
559  d5.set_nonreal(d2.nonreal()-d4.nonreal());
560  d4=d2-d4;
561  TEST_ASSERT(d4.exact(d5));
562 
563  // test B-=A
564  d4=d3;
565  d5.set_real(d2.real()-d4.real());
566  d5.set_nonreal(d2.nonreal()-d4.nonreal());
567  d4-=d2;
568  TEST_ASSERT(d4.exact(d5));
569 
570  // test B-=v
571  d4=d3;
572  d5.set_real(d2.real()-v1);
573  d5.set_nonreal(d2.nonreal()-0);
574  d4-=v1;
575  TEST_ASSERT(d4.exact(d5));
576 
577  // test B-=int
578  d4=d3;
579  d5.set_real(d2.real()-2);
580  d5.set_nonreal(d2.nonreal()-0);
581  d4-=2;
582  TEST_ASSERT(d4.exact(d5));
583 
584  // test C-=A-B
585  d4=d3;
586  d5.set_real(d4.real()-(d1.real()-d2.real()));
587  d5.set_nonreal(d4.nonreal()-(d1.nonreal()-d2.nonreal()));
588  d4-=d1-d2;
589  TEST_ASSERT(d4.exact(d5));
590 
591  // test D=(A-B)-C
592  d5.set_real((d1.real()-d2.real())-d3.real());
593  d5.set_nonreal((d1.nonreal()-d2.nonreal())-d3.nonreal());
594  d4=(d1-d2)-d3;
595  TEST_ASSERT(d4.exact(d5));
596 
597  // test D=A-(B-C)
598  d5.set_real(d1.real()-(d2.real()-d3.real()));
599  d5.set_nonreal(d1.nonreal()-(d2.nonreal()-d3.nonreal()));
600  d4=d1-(d2-d3);
601  TEST_ASSERT(d4.exact(d5));
602 
603  // test D=A-B-C
604  d5.set_real(d1.real()-d2.real()-d3.real());
605  d5.set_nonreal(d1.nonreal()-d2.nonreal()-d3.nonreal());
606  d4=d1-d2-d3;
607  TEST_ASSERT(d4.exact(d5));
608 
609  // test D=(A-B)-(C+C)
610  d5.set_real((d1.real()-d2.real())-(d3.real()+d3.real()));
611  d5.set_nonreal((d1.nonreal()-d2.nonreal())-(d3.nonreal()+d3.nonreal()));
612  d4=(d1-d2)-(d3+d3);
613  TEST_ASSERT(d4.exact(d5));
614 
615  // test C=A-v
616  d5.set_real(d2.real()-v1);
617  d5.set_nonreal(d2.nonreal()-0);
618  d4=d2-v1;
619  TEST_ASSERT(d4.exact(d5));
620 
621  // test C=v-A
622  d5.set_real(v1-d2.real());
623  d5.set_nonreal(0-d2.nonreal());
624  d4=v1-d2;
625  TEST_ASSERT(d4.exact(d5));
626 
627  // test C=A-B-v
628  d5.set_real(d2.real()-d3.real()-v1);
629  d5.set_nonreal(d2.nonreal()-d3.nonreal()-0);
630  d4=d2-d3-v1;
631  TEST_ASSERT(d4.exact(d5));
632 
633  // test C=v-A-B
634  d5.set_real(v1-d2.real()-d3.real());
635  d5.set_nonreal(0-d2.nonreal()-d3.nonreal());
636  d4=v1-d2-d3;
637  TEST_ASSERT(d4.exact(d5));
638 
639  // test C=A-int
640  d5.set_real(d2.real()-2);
641  d5.set_nonreal(d2.nonreal()-0);
642  d4=d2-2;
643  TEST_ASSERT(d4.exact(d5));
644 
645  // test C=int-A
646  d5.set_real(2-d2.real());
647  d5.set_nonreal(0-d2.nonreal());
648  d4=2-d2;
649  TEST_ASSERT(d4.exact(d5));
650  }
651 
653  {
654  eli::mutil::ad::dual<data__, false> d1(3,-4), d2(1,2), d3(d2), d4, d5, d6;
655  data__ v1(2);
656 
657  // test C=A*B
658  d5.set_real(d2.real()*d3.real());
659  d5.set_nonreal(d2.real()*d3.nonreal()+d2.nonreal()*d3.real());
660  d4=d2*d3;
661  TEST_ASSERT(d4.exact(d5));
662 
663  // test B=A*B
664  d4=d3;
665  d5.set_real(d2.real()*d4.real());
666  d5.set_nonreal(d2.real()*d4.nonreal()+d2.nonreal()*d4.real());
667  d4=d2*d4;
668  TEST_ASSERT(d4.exact(d5));
669 
670  // test B*=A
671  d4=d3;
672  d5.set_real(d2.real()*d4.real());
673  d5.set_nonreal(d2.real()*d4.nonreal()+d2.nonreal()*d4.real());
674  d4*=d2;
675  TEST_ASSERT(d4.exact(d5));
676 
677  // test B*=v
678  d4=d3;
679  d5.set_real(d2.real()*v1);
680  d5.set_nonreal(d2.nonreal()*v1);
681  d4*=v1;
682  TEST_ASSERT(d4.exact(d5));
683 
684  // test B*=int
685  d4=d3;
686  d5.set_real(d2.real()*2);
687  d5.set_nonreal(d2.nonreal()*2);
688  d4*=2;
689  TEST_ASSERT(d4.exact(d5));
690 
691  // test C*=A-B
692  d4=d3;
693  d6=d1-d2;
694  d5.set_real(d4.real()*d6.real());
695  d5.set_nonreal(d4.real()*d6.nonreal()+d4.nonreal()*d6.real());
696  d4*=d1-d2;
697  TEST_ASSERT(d4.exact(d5));
698 
699  // test D=(A-B)*C
700  d6=d1-d2;
701  d5.set_real(d6.real()*d3.real());
702  d5.set_nonreal(d6.real()*d3.nonreal()+d6.nonreal()*d3.real());
703  d4=(d1-d2)*d3;
704  TEST_ASSERT(d4.exact(d5));
705 
706  // test D=A*(B-C)
707  d6=d2-d3;
708  d5.set_real(d1.real()*d6.real());
709  d5.set_nonreal(d1.real()*d6.nonreal()+d1.nonreal()*d6.real());
710  d4=d1*(d2-d3);
711  TEST_ASSERT(d4.exact(d5));
712 
713  // test D=A*B*C
714  d6.set_real(d1.real()*d2.real());
715  d6.set_nonreal(d1.real()*d2.nonreal()+d1.nonreal()*d2.real());
716  d5.set_real(d6.real()*d3.real());
717  d5.set_nonreal(d6.real()*d3.nonreal()+d6.nonreal()*d3.real());
718  d4=d1*d2*d3;
719  TEST_ASSERT(d4.exact(d5));
720 
721  // test D=(A*B)-(C*C)
722  d5.set_real(d1.real()*d2.real());
723  d5.set_nonreal(d1.real()*d2.nonreal()+d1.nonreal()*d2.real());
724  d6.set_real(d3.real()*d3.real());
725  d6.set_nonreal(d3.real()*d3.nonreal()+d3.nonreal()*d3.real());
726  d5-=d6;
727  d4=(d1*d2)-(d3*d3);
728  TEST_ASSERT(d4.exact(d5));
729 
730  // test C=A*v
731  d5.set_real(d2.real()*v1);
732  d5.set_nonreal(d2.nonreal()*v1);
733  d4=d2*v1;
734  TEST_ASSERT(d4.exact(d5));
735 
736  // test C=v*A
737  d5.set_real(v1*d2.real());
738  d5.set_nonreal(v1*d2.nonreal());
739  d4=v1*d2;
740  TEST_ASSERT(d4.exact(d5));
741 
742  // test C=A*B*v
743  d5.set_real(d2.real()*d3.real()*v1);
744  d5.set_nonreal((d2.real()*d3.nonreal()+d2.nonreal()*d3.real())*v1);
745  d4=d2*d3*v1;
746  TEST_ASSERT(d4.exact(d5));
747 
748  // test C=v*A*B
749  d5.set_real(v1*d2.real()*d3.real());
750  d5.set_nonreal(v1*(d2.real()*d3.nonreal()+d2.nonreal()*d3.real()));
751  d4=v1*d2*d3;
752  TEST_ASSERT(d4.exact(d5));
753 
754  // test C=A*int
755  d5.set_real(d2.real()*2);
756  d5.set_nonreal(d2.nonreal()*2);
757  d4=d2*2;
758  TEST_ASSERT(d4.exact(d5));
759 
760  // test C=int*A
761  d5.set_real(2*d2.real());
762  d5.set_nonreal(2*d2.nonreal());
763  d4=2*d2;
764  TEST_ASSERT(d4.exact(d5));
765  }
766 
768  {
769  eli::mutil::ad::dual<data__, false> d1(3,-4), d2(1,2), d3(d2), d4, d5, d6, d7;
770  data__ v1(2);
771 
772  // test C=A/B
773  d5.set_real(d2.real()/d3.real());
774  d5.set_nonreal((d2.nonreal()*d3.real()-d2.real()*d3.nonreal())/d3.real()/d3.real());
775  d4=d2/d3;
776  TEST_ASSERT(d4.exact(d5));
777 
778  // test B=A/B
779  d4=d3;
780  d5.set_real(d2.real()/d4.real());
781  d5.set_nonreal((d2.nonreal()*d4.real()-d2.real()*d4.nonreal())/d4.real()/d4.real());
782  d4=d2/d4;
783  TEST_ASSERT(d4.exact(d5));
784 
785  // test B/=A
786  d4=d3;
787  d5.set_real(d2.real()/d4.real());
788  d5.set_nonreal((d2.nonreal()/d4.real()-d2.real()*d4.nonreal())/d4.real()/d4.real());
789  d4/=d2;
790  TEST_ASSERT(d4.exact(d5));
791 
792  // test B/=v
793  d4=d3;
794  d5.set_real(d2.real()/v1);
795  d5.set_nonreal(d2.nonreal()/v1);
796  d4/=v1;
797  TEST_ASSERT(d4.exact(d5));
798 
799  // test B/=int
800  d4=d3;
801  d5.set_real(d2.real()/2);
802  d5.set_nonreal(d2.nonreal()/2);
803  d4/=2;
804  TEST_ASSERT(d4.exact(d5));
805 
806  // test C/=A-B
807  d4=d3;
808  d6=d1-d2;
809  d5.set_real(d4.real()/d6.real());
810  d5.set_nonreal((d4.nonreal()*d6.real()-d4.real()*d6.nonreal())/d6.real()/d6.real());
811  d4/=d1-d2;
812  TEST_ASSERT(d4.exact(d5));
813 
814  // test D=(A-B)/C
815  d6=d1-d2;
816  d5.set_real(d6.real()/d3.real());
817  d5.set_nonreal((d6.nonreal()*d3.real()-d6.real()*d3.nonreal())/d3.real()/d3.real());
818  d4=(d1-d2)/d3;
819  TEST_ASSERT(d4.exact(d5));
820 
821  // test D=A/(B-C)
822  d6=d1-d2;
823  d5.set_real(d1.real()/d6.real());
824  d5.set_nonreal((d1.nonreal()*d6.real()-d1.real()*d6.nonreal())/d6.real()/d6.real());
825  d4=d1/(d1-d2);
826  TEST_ASSERT(d4.exact(d5));
827 
828  // test D=A*B*C
829  d6.set_real(d1.real()/d2.real());
830  d6.set_nonreal((d1.nonreal()*d2.real()-d1.real()*d2.nonreal())/d2.real()/d2.real());
831  d5.set_real(d6.real()/d3.real());
832  d5.set_nonreal((d6.nonreal()*d3.real()-d6.real()*d3.nonreal())/d3.real()/d3.real());
833  d4=d1/d2/d3;
834  TEST_ASSERT(d4.exact(d5));
835 
836  // test E=(A/B)-(C/D)
837  d5.set_real(d1.real()/d2.real());
838  d5.set_nonreal((d1.nonreal()*d2.real()-d1.real()*d2.nonreal())/d2.real()/d2.real());
839  TEST_ASSERT(d5.exact(d1/d2));
840  d6.set_real(d3.real()/d4.real());
841  d6.set_nonreal((d3.nonreal()*d4.real()-d3.real()*d4.nonreal())/d4.real()/d4.real());
842  TEST_ASSERT(d6.exact(d3/d4));
843  d5-=d6;
844  d7=(d1/d2)-(d3/d4);
845  TEST_ASSERT(d7.exact(d5));
846 
847  // test C=A/v
848  d5.set_real(d2.real()/v1);
849  d5.set_nonreal(d2.nonreal()/v1);
850  d4=d2/v1;
851  TEST_ASSERT(d4.exact(d5));
852 
853  // test C=v/A
854  d5.set_real(v1/d2.real());
855  d5.set_nonreal(-v1*d2.nonreal()/d2.real()/d2.real());
856  d4=v1/d2;
857  TEST_ASSERT(d4.exact(d5));
858 
859  // test C=A/B/v
860  d5.set_real(d2.real()/d3.real()/v1);
861  d5.set_nonreal((d2.nonreal()*d3.real()-d2.real()*d3.nonreal())/d3.real()/d3.real()/v1);
862  d4=d2/d3/v1;
863  TEST_ASSERT(d4.exact(d5));
864 
865  // test C=v/A/B
866  d6.set_real(v1/d2.real());
867  d6.set_nonreal(-v1*d2.nonreal()/d2.real()/d2.real());
868  d5.set_real(d6.real()/d3.real());
869  d5.set_nonreal((d6.nonreal()*d3.real()-d6.real()*d3.nonreal())/d3.real()/d3.real());
870  d4=v1/d2/d3;
871  TEST_ASSERT(d4.exact(d5));
872 
873  // test C=A/int
874  d5.set_real(d2.real()/2);
875  d5.set_nonreal(d2.nonreal()/2);
876  d4=d2/2;
877  TEST_ASSERT(d4.exact(d5));
878 
879  // test C=int/A
880  d5.set_real(2/d2.real());
881  d5.set_nonreal(-2*d2.nonreal()/d2.real()/d2.real());
882  d4=2/d2;
883  TEST_ASSERT(d4.exact(d5));
884  }
885 
887  {
888  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
889  data__ v1(4);
890  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
891 
892  // sin(dual) test
893  d3=d1;
894  dref.set_real(std::sin(d3.real()));
895  dref.set_nonreal(d3.nonreal()*std::cos(d3.real()));
896  d0=std::sin(d3);
897  TEST_ASSERT(d0.nearly(dref, tol));
898 
899  // sin(expression) test
900  d3=d1+d2;
901  dref.set_real(std::sin(d3.real()));
902  dref.set_nonreal(d3.nonreal()*std::cos(d3.real()));
903  d0=std::sin(d1+d2);
904  TEST_ASSERT(d0.nearly(dref, tol));
905 
906  // sin(sin(expression)) test
907  d3=d1+d2;
908  d4.set_real(std::sin(d3.real()));
909  d4.set_nonreal(d3.nonreal()*std::cos(d3.real()));
910  dref.set_real(std::sin(d4.real()));
911  dref.set_nonreal(d4.nonreal()*std::cos(d4.real()));
912  d0=std::sin(std::sin(d1+d2));
913  TEST_ASSERT(d0.nearly(dref, tol));
914 
915  // cos(dual) test
916  d3=d1;
917  dref.set_real(std::cos(d3.real()));
918  dref.set_nonreal(-d3.nonreal()*std::sin(d3.real()));
919  d0=std::cos(d3);
920  TEST_ASSERT(d0.nearly(dref, tol));
921 
922  // cos(expression) test
923  d3=d1+d2;
924  dref.set_real(std::cos(d3.real()));
925  dref.set_nonreal(-d3.nonreal()*std::sin(d3.real()));
926  d0=std::cos(d1+d2);
927  TEST_ASSERT(d0.nearly(dref, tol));
928 
929  // cos(cos(expression)) test
930  d3=d1+d2;
931  d4.set_real(std::cos(d3.real()));
932  d4.set_nonreal(-d3.nonreal()*std::sin(d3.real()));
933  dref.set_real(std::cos(d4.real()));
934  dref.set_nonreal(-d4.nonreal()*std::sin(d4.real()));
935  d0=std::cos(std::cos(d1+d2));
936  TEST_ASSERT(d0.nearly(dref, tol));
937 
938  // tan(dual) test
939  d3=d1;
940  dref.set_real(std::tan(d3.real()));
941  dref.set_nonreal(d3.nonreal()/std::cos(d3.real())/std::cos(d3.real()));
942  d0=std::tan(d3);
943  TEST_ASSERT(d0.nearly(dref, tol));
944 
945  // tan(expression) test
946  d3=d1+d2;
947  dref.set_real(std::tan(d3.real()));
948  dref.set_nonreal(d3.nonreal()/std::cos(d3.real())/std::cos(d3.real()));
949  d0=std::tan(d1+d2);
950  TEST_ASSERT(d0.nearly(dref, tol));
951 
952  // tan(tan(expression)) test
953  d3=d1+d2;
954  d4.set_real(std::tan(d3.real()));
955  d4.set_nonreal(d3.nonreal()/std::cos(d3.real())/std::cos(d3.real()));
956  dref.set_real(std::tan(d4.real()));
957  dref.set_nonreal(d4.nonreal()/std::cos(d4.real())/std::cos(d4.real()));
958  d0=std::tan(std::tan(d1+d2));
959  TEST_ASSERT(d0.nearly(dref, tol));
960 
961  // asin(dual) test
962  d3=d1/v1;
963  dref.set_real(std::asin(d3.real()));
964  dref.set_nonreal(d3.nonreal()/std::sqrt(1-d3.real()*d3.real()));
965  d0=std::asin(d3);
966  TEST_ASSERT(d0.nearly(dref, tol));
967 
968  // asin(expression) test
969  d3=(d1+d2)/v1;
970  dref.set_real(std::asin(d3.real()));
971  dref.set_nonreal(d3.nonreal()/std::sqrt(1-d3.real()*d3.real()));
972  d0=std::asin((d1+d2)/v1);
973  TEST_ASSERT(d0.nearly(dref, tol));
974 
975  // asin(sin(expression)) test
976  d3=(d1+d2)/v1;
977  dref=d3;
978  d0=std::asin(std::sin((d1+d2)/v1));
979  TEST_ASSERT(d0.nearly(dref, tol));
980 
981  // acos(dual) test
982  d3=d1/v1;
983  dref.set_real(std::acos(d3.real()));
984  dref.set_nonreal(-d3.nonreal()/std::sqrt(1-d3.real()*d3.real()));
985  d0=std::acos(d3);
986  TEST_ASSERT(d0.nearly(dref, tol));
987 
988  // acos(expression) test
989  d3=(d1+d2)/v1;
990  dref.set_real(std::acos(d3.real()));
991  dref.set_nonreal(-d3.nonreal()/std::sqrt(1-d3.real()*d3.real()));
992  d0=std::acos((d1+d2)/v1);
993  TEST_ASSERT(d0.nearly(dref, tol));
994 
995  // acos(cos(expression)) test
996  d3=(d1+d2)/v1;
997  dref=d3;
998  d0=std::acos(std::cos((d1+d2)/v1));
999  TEST_ASSERT(d0.nearly(dref, tol));
1000 
1001  // atan(dual) test
1002  d3=d1/v1;
1003  dref.set_real(std::atan(d3.real()));
1004  dref.set_nonreal(d3.nonreal()/(1+d3.real()*d3.real()));
1005  d0=std::atan(d3);
1006  TEST_ASSERT(d0.nearly(dref, tol));
1007 
1008  // atan(expression) test
1009  d3=(d1+d2)/v1;
1010  dref.set_real(std::atan(d3.real()));
1011  dref.set_nonreal(d3.nonreal()/(1+d3.real()*d3.real()));
1012  d0=std::atan((d1+d2)/v1);
1013  TEST_ASSERT(d0.nearly(dref, tol));
1014 
1015  // atan(tan(expression)) test
1016  d3=(d1+d2)/v1;
1017  dref=d3;
1018  d0=std::atan(std::tan((d1+d2)/v1));
1019  TEST_ASSERT(d0.nearly(dref, tol));
1020  // TODO: ADD atan2 test when bin_fun implemented
1021  }
1022 
1024  {
1025  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1026  data__ v1(4);
1027  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1028 
1029  // sin(dual) test
1030  d3=d1;
1031  dref.set_real(sin(d3.real()));
1032  dref.set_nonreal(d3.nonreal()*cos(d3.real()));
1033  d0=sin(d3);
1034  TEST_ASSERT(d0.nearly(dref, tol));
1035 
1036  // sin(expression) test
1037  d3=d1+d2;
1038  dref.set_real(sin(d3.real()));
1039  dref.set_nonreal(d3.nonreal()*cos(d3.real()));
1040  d0=sin(d1+d2);
1041  TEST_ASSERT(d0.nearly(dref, tol));
1042 
1043  // sin(sin(expression)) test
1044  d3=d1+d2;
1045  d4.set_real(sin(d3.real()));
1046  d4.set_nonreal(d3.nonreal()*cos(d3.real()));
1047  dref.set_real(sin(d4.real()));
1048  dref.set_nonreal(d4.nonreal()*cos(d4.real()));
1049  d0=sin(sin(d1+d2));
1050  TEST_ASSERT(d0.nearly(dref, tol));
1051 
1052  // cos(dual) test
1053  d3=d1;
1054  dref.set_real(cos(d3.real()));
1055  dref.set_nonreal(-d3.nonreal()*sin(d3.real()));
1056  d0=cos(d3);
1057  TEST_ASSERT(d0.nearly(dref, tol));
1058 
1059  // cos(expression) test
1060  d3=d1+d2;
1061  dref.set_real(cos(d3.real()));
1062  dref.set_nonreal(-d3.nonreal()*sin(d3.real()));
1063  d0=cos(d1+d2);
1064  TEST_ASSERT(d0.nearly(dref, tol));
1065 
1066  // cos(cos(expression)) test
1067  d3=d1+d2;
1068  d4.set_real(cos(d3.real()));
1069  d4.set_nonreal(-d3.nonreal()*sin(d3.real()));
1070  dref.set_real(cos(d4.real()));
1071  dref.set_nonreal(-d4.nonreal()*sin(d4.real()));
1072  d0=cos(cos(d1+d2));
1073  TEST_ASSERT(d0.nearly(dref, tol));
1074 
1075  // tan(dual) test
1076  d3=d1;
1077  dref.set_real(tan(d3.real()));
1078  dref.set_nonreal(d3.nonreal()/cos(d3.real())/cos(d3.real()));
1079  d0=tan(d3);
1080  TEST_ASSERT(d0.nearly(dref, tol));
1081 
1082  // tan(expression) test
1083  d3=d1+d2;
1084  dref.set_real(tan(d3.real()));
1085  dref.set_nonreal(d3.nonreal()/cos(d3.real())/cos(d3.real()));
1086  d0=tan(d1+d2);
1087  TEST_ASSERT(d0.nearly(dref, tol));
1088 
1089  // tan(tan(expression)) test
1090  d3=d1+d2;
1091  d4.set_real(tan(d3.real()));
1092  d4.set_nonreal(d3.nonreal()/cos(d3.real())/cos(d3.real()));
1093  dref.set_real(tan(d4.real()));
1094  dref.set_nonreal(d4.nonreal()/cos(d4.real())/cos(d4.real()));
1095  d0=tan(tan(d1+d2));
1096  TEST_ASSERT(d0.nearly(dref, tol));
1097 
1098  // asin(dual) test
1099  d3=d1/v1;
1100  dref.set_real(asin(d3.real()));
1101  dref.set_nonreal(d3.nonreal()/sqrt(1-d3.real()*d3.real()));
1102  d0=asin(d3);
1103  TEST_ASSERT(d0.nearly(dref, tol));
1104 
1105  // asin(expression) test
1106  d3=(d1+d2)/v1;
1107  dref.set_real(asin(d3.real()));
1108  dref.set_nonreal(d3.nonreal()/sqrt(1-d3.real()*d3.real()));
1109  d0=asin((d1+d2)/v1);
1110  TEST_ASSERT(d0.nearly(dref, tol));
1111 
1112  // asin(sin(expression)) test
1113  d3=(d1+d2)/v1;
1114  dref=d3;
1115  d0=asin(sin((d1+d2)/v1));
1116  TEST_ASSERT(d0.nearly(dref, tol));
1117 
1118  // acos(dual) test
1119  d3=d1/v1;
1120  dref.set_real(acos(d3.real()));
1121  dref.set_nonreal(-d3.nonreal()/sqrt(1-d3.real()*d3.real()));
1122  d0=acos(d3);
1123  TEST_ASSERT(d0.nearly(dref, tol));
1124 
1125  // acos(expression) test
1126  d3=(d1+d2)/v1;
1127  dref.set_real(acos(d3.real()));
1128  dref.set_nonreal(-d3.nonreal()/sqrt(1-d3.real()*d3.real()));
1129  d0=acos((d1+d2)/v1);
1130  TEST_ASSERT(d0.nearly(dref, tol));
1131 
1132  // acos(cos(expression)) test
1133  d3=(d1+d2)/v1;
1134  dref=d3;
1135  d0=acos(cos((d1+d2)/v1));
1136  TEST_ASSERT(d0.nearly(dref, tol));
1137 
1138  // atan(dual) test
1139  d3=d1/v1;
1140  dref.set_real(atan(d3.real()));
1141  dref.set_nonreal(d3.nonreal()/(1+d3.real()*d3.real()));
1142  d0=atan(d3);
1143  TEST_ASSERT(d0.nearly(dref, tol));
1144 
1145  // atan(expression) test
1146  d3=(d1+d2)/v1;
1147  dref.set_real(atan(d3.real()));
1148  dref.set_nonreal(d3.nonreal()/(1+d3.real()*d3.real()));
1149  d0=atan((d1+d2)/v1);
1150  TEST_ASSERT(d0.nearly(dref, tol));
1151 
1152  // tan(tan(expression)) test
1153  d3=(d1+d2)/v1;
1154  dref=d3;
1155  d0=atan(std::tan((d1+d2)/v1));
1156  TEST_ASSERT(d0.nearly(dref, tol));
1157 
1158  // TODO: ADD atan2 test when bin_fun implemented
1159  }
1160 
1162  {
1163  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1164  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1165 
1166  // sinh(dual) test
1167  d3=d1;
1168  dref.set_real(std::sinh(d3.real()));
1169  dref.set_nonreal(d3.nonreal()*std::cosh(d3.real()));
1170  d0=std::sinh(d3);
1171  TEST_ASSERT(d0.nearly(dref, tol));
1172 
1173  // sinh(expression) test
1174  d3=d1+d2;
1175  dref.set_real(std::sinh(d3.real()));
1176  dref.set_nonreal(d3.nonreal()*std::cosh(d3.real()));
1177  d0=std::sinh(d1+d2);
1178  TEST_ASSERT(d0.nearly(dref, tol));
1179 
1180  // sinh(sinh(expression)) test
1181  d3=d1+d2;
1182  d4.set_real(std::sinh(d3.real()));
1183  d4.set_nonreal(d3.nonreal()*std::cosh(d3.real()));
1184  dref.set_real(std::sinh(d4.real()));
1185  dref.set_nonreal(d4.nonreal()*std::cosh(d4.real()));
1186  d0=std::sinh(std::sinh(d1+d2));
1187 #if defined(_MSC_VER) && defined(NDEBUG) && !defined(_WIN64)
1188  TEST_ASSERT(d0.nearly(dref, static_cast<data__>(1e-2)));
1189 #else
1190  TEST_ASSERT(d0.nearly(dref, tol));
1191 #endif
1192 
1193  // cosh(dual) test
1194  d3=d1;
1195  dref.set_real(std::cosh(d3.real()));
1196  dref.set_nonreal(d3.nonreal()*std::sinh(d3.real()));
1197  d0=std::cosh(d3);
1198  TEST_ASSERT(d0.nearly(dref, tol));
1199 
1200  // cosh(expression) test
1201  d3=d1+d2;
1202  dref.set_real(std::cosh(d3.real()));
1203  dref.set_nonreal(d3.nonreal()*std::sinh(d3.real()));
1204  d0=std::cosh(d1+d2);
1205  TEST_ASSERT(d0.nearly(dref, tol));
1206 
1207  // cosh(cosh(expression)) test
1208  d3=d1+d2;
1209  d4.set_real(std::cosh(d3.real()));
1210  d4.set_nonreal(d3.nonreal()*std::sinh(d3.real()));
1211  dref.set_real(std::cosh(d4.real()));
1212  dref.set_nonreal(d4.nonreal()*std::sinh(d4.real()));
1213  d0=std::cosh(std::cosh(d1+d2));
1214 #if defined(_MSC_VER) && defined(NDEBUG) && !defined(_WIN64)
1215  TEST_ASSERT(d0.nearly(dref, static_cast<data__>(2e-3)));
1216 #else
1217  TEST_ASSERT(d0.nearly(dref, tol));
1218 #endif
1219 
1220  // tanh(dual) test
1221  d3=d1;
1222  dref.set_real(std::tanh(d3.real()));
1223  dref.set_nonreal(d3.nonreal()/std::cosh(d3.real())/std::cosh(d3.real()));
1224  d0=std::tanh(d3);
1225  TEST_ASSERT(d0.nearly(dref, tol));
1226 
1227  // tanh(expression) test
1228  d3=d1+d2;
1229  dref.set_real(std::tanh(d3.real()));
1230  dref.set_nonreal(d3.nonreal()/std::cosh(d3.real())/std::cosh(d3.real()));
1231  d0=std::tanh(d1+d2);
1232  TEST_ASSERT(d0.nearly(dref, tol));
1233 
1234  // tanh(tanh(expression)) test
1235  d3=d1+d2;
1236  d4.set_real(std::tanh(d3.real()));
1237  d4.set_nonreal(d3.nonreal()/std::cosh(d3.real())/std::cosh(d3.real()));
1238  dref.set_real(std::tanh(d4.real()));
1239  dref.set_nonreal(d4.nonreal()/std::cosh(d4.real())/std::cosh(d4.real()));
1240  d0=std::tanh(std::tanh(d1+d2));
1241  TEST_ASSERT(d0.nearly(dref, tol));
1242 
1243  // asinh(dual) test
1244  d3=d1;
1245  dref.set_real(std::asinh(d3.real()));
1246  dref.set_nonreal(d3.nonreal()/std::sqrt(1+d3.real()*d3.real()));
1247  d0=std::asinh(d3);
1248  TEST_ASSERT(d0.nearly(dref, tol));
1249 
1250  // asinh(expression) test
1251  d3=(d1+d2);
1252  dref.set_real(std::asinh(d3.real()));
1253  dref.set_nonreal(d3.nonreal()/std::sqrt(1+d3.real()*d3.real()));
1254  d0=std::asinh((d1+d2));
1255  TEST_ASSERT(d0.nearly(dref, tol));
1256 
1257  // asinh(sinh(expression)) test
1258  d3=(d1+d2);
1259  dref=d3;
1260  d0=std::asinh(std::sinh(d1+d2));
1261  TEST_ASSERT(d0.nearly(dref, tol));
1262 
1263  // acosh(dual) test
1264  d3=d1;
1265  dref.set_real(std::acosh(d3.real()));
1266  dref.set_nonreal(d3.nonreal()/std::sqrt(d3.real()*d3.real()-1));
1267  d0=std::acosh(d3);
1268  TEST_ASSERT(d0.nearly(dref, tol));
1269 
1270  // acosh(expression) test
1271  d3=(d1+d2);
1272  dref.set_real(std::acosh(d3.real()));
1273  dref.set_nonreal(d3.nonreal()/std::sqrt(d3.real()*d3.real()-1));
1274  d0=std::acosh(d1+d2);
1275  TEST_ASSERT(d0.nearly(dref, tol));
1276 
1277  // acosh(cosh(expression)) test
1278  d3=(d1+d2);
1279  dref=d3;
1280  d0=std::acosh(std::cosh(d1+d2));
1281  TEST_ASSERT(d0.nearly(dref, tol));
1282 
1283  // atanh(dual) test
1284  d3=d1/4;
1285  dref.set_real(std::atanh(d3.real()));
1286  dref.set_nonreal(d3.nonreal()/(1-d3.real()*d3.real()));
1287  d0=std::atanh(d3);
1288  TEST_ASSERT(d0.nearly(dref, tol));
1289 
1290  // atanh(expression) test
1291  d3=(d1+d2)/8;
1292  dref.set_real(std::atanh(d3.real()));
1293  dref.set_nonreal(d3.nonreal()/(1-d3.real()*d3.real()));
1294  d0=std::atanh((d1+d2)/8);
1295  TEST_ASSERT(d0.nearly(dref, tol));
1296 
1297  // atanh(tanh(expression)) test
1298  d3=(d1+d2)/4;
1299  dref=d3;
1300  d0=std::atanh(std::tanh((d1+d2)/4));
1301  TEST_ASSERT(d0.nearly(dref, tol));
1302  }
1303 
1305  {
1306  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1307  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1308 
1309  // sinh(dual) test
1310  d3=d1;
1311  dref.set_real(sinh(d3.real()));
1312  dref.set_nonreal(d3.nonreal()*cosh(d3.real()));
1313  d0=sinh(d3);
1314  TEST_ASSERT(d0.nearly(dref, tol));
1315 
1316  // sinh(expression) test
1317  d3=d1+d2;
1318  dref.set_real(sinh(d3.real()));
1319  dref.set_nonreal(d3.nonreal()*cosh(d3.real()));
1320  d0=sinh(d1+d2);
1321  TEST_ASSERT(d0.nearly(dref, tol));
1322 
1323  // sinh(sinh(expression)) test
1324  d3=d1+d2;
1325  d4.set_real(sinh(d3.real()));
1326  d4.set_nonreal(d3.nonreal()*cosh(d3.real()));
1327  dref.set_real(sinh(d4.real()));
1328  dref.set_nonreal(d4.nonreal()*cosh(d4.real()));
1329  d0=sinh(sinh(d1+d2));
1330 #if defined(_MSC_VER) && defined(NDEBUG) && !defined(_WIN64)
1331  TEST_ASSERT(d0.nearly(dref, static_cast<data__>(1e-2)));
1332 #else
1333  TEST_ASSERT(d0.nearly(dref, tol));
1334 #endif
1335 
1336  // cosh(dual) test
1337  d3=d1;
1338  dref.set_real(cosh(d3.real()));
1339  dref.set_nonreal(d3.nonreal()*sinh(d3.real()));
1340  d0=cosh(d3);
1341  TEST_ASSERT(d0.nearly(dref, tol));
1342 
1343  // cosh(expression) test
1344  d3=d1+d2;
1345  dref.set_real(cosh(d3.real()));
1346  dref.set_nonreal(d3.nonreal()*sinh(d3.real()));
1347  d0=cosh(d1+d2);
1348  TEST_ASSERT(d0.nearly(dref, tol));
1349 
1350  // cosh(cosh(expression)) test
1351  d3=d1+d2;
1352  d4.set_real(cosh(d3.real()));
1353  d4.set_nonreal(d3.nonreal()*sinh(d3.real()));
1354  dref.set_real(cosh(d4.real()));
1355  dref.set_nonreal(d4.nonreal()*sinh(d4.real()));
1356  d0=cosh(cosh(d1+d2));
1357 #if defined(_MSC_VER) && defined(NDEBUG) && !defined(_WIN64)
1358  TEST_ASSERT(d0.nearly(dref, static_cast<data__>(2e-3)));
1359 #else
1360  TEST_ASSERT(d0.nearly(dref, tol));
1361 #endif
1362 
1363  // tanh(dual) test
1364  d3=d1;
1365  dref.set_real(tanh(d3.real()));
1366  dref.set_nonreal(d3.nonreal()/cosh(d3.real())/cosh(d3.real()));
1367  d0=tanh(d3);
1368  TEST_ASSERT(d0.nearly(dref, tol));
1369 
1370  // tanh(expression) test
1371  d3=d1+d2;
1372  dref.set_real(tanh(d3.real()));
1373  dref.set_nonreal(d3.nonreal()/cosh(d3.real())/cosh(d3.real()));
1374  d0=tanh(d1+d2);
1375  TEST_ASSERT(d0.nearly(dref, tol));
1376 
1377  // tanh(tanh(expression)) test
1378  d3=d1+d2;
1379  d4.set_real(tanh(d3.real()));
1380  d4.set_nonreal(d3.nonreal()/cosh(d3.real())/cosh(d3.real()));
1381  dref.set_real(tanh(d4.real()));
1382  dref.set_nonreal(d4.nonreal()/cosh(d4.real())/cosh(d4.real()));
1383  d0=tanh(tanh(d1+d2));
1384  TEST_ASSERT(d0.nearly(dref, tol));
1385 
1386  // asinh(dual) test
1387  d3=d1;
1388  dref.set_real(asinh(d3.real()));
1389  dref.set_nonreal(d3.nonreal()/sqrt(1+d3.real()*d3.real()));
1390  d0=asinh(d3);
1391  TEST_ASSERT(d0.nearly(dref, tol));
1392 
1393  // asinh(expression) test
1394  d3=(d1+d2);
1395  dref.set_real(asinh(d3.real()));
1396  dref.set_nonreal(d3.nonreal()/sqrt(1+d3.real()*d3.real()));
1397  d0=asinh((d1+d2));
1398  TEST_ASSERT(d0.nearly(dref, tol));
1399 
1400  // asinh(sinh(expression)) test
1401  d3=(d1+d2);
1402  dref=d3;
1403  d0=asinh(sinh(d1+d2));
1404  TEST_ASSERT(d0.nearly(dref, tol));
1405 
1406  // acosh(dual) test
1407  d3=d1;
1408  dref.set_real(acosh(d3.real()));
1409  dref.set_nonreal(d3.nonreal()/sqrt(d3.real()*d3.real()-1));
1410  d0=acosh(d3);
1411  TEST_ASSERT(d0.nearly(dref, tol));
1412 
1413  // acosh(expression) test
1414  d3=(d1+d2);
1415  dref.set_real(acosh(d3.real()));
1416  dref.set_nonreal(d3.nonreal()/sqrt(d3.real()*d3.real()-1));
1417  d0=acosh(d1+d2);
1418  TEST_ASSERT(d0.nearly(dref, tol));
1419 
1420  // acosh(cosh(expression)) test
1421  d3=(d1+d2);
1422  dref=d3;
1423  d0=acosh(cosh(d1+d2));
1424  TEST_ASSERT(d0.nearly(dref, tol));
1425 
1426  // atanh(dual) test
1427  d3=d1/4;
1428  dref.set_real(atanh(d3.real()));
1429  dref.set_nonreal(d3.nonreal()/(1-d3.real()*d3.real()));
1430  d0=atanh(d3);
1431  TEST_ASSERT(d0.nearly(dref, tol));
1432 
1433  // atanh(expression) test
1434  d3=(d1+d2)/8;
1435  dref.set_real(atanh(d3.real()));
1436  dref.set_nonreal(d3.nonreal()/(1-d3.real()*d3.real()));
1437  d0=atanh((d1+d2)/8);
1438  TEST_ASSERT(d0.nearly(dref, tol));
1439 
1440  // atanh(tanh(expression)) test
1441  d3=(d1+d2)/4;
1442  dref=d3;
1443  d0=atanh(tanh((d1+d2)/4));
1444  TEST_ASSERT(d0.nearly(dref, tol));
1445  }
1446 
1448  {
1449  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1450  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon())), two(2), ten(10);
1451 
1452  // exp(dual) test
1453  d3=d1;
1454  dref.set_real(std::exp(d3.real()));
1455  dref.set_nonreal(d3.nonreal()*std::exp(d3.real()));
1456  d0=std::exp(d3);
1457  TEST_ASSERT(d0.nearly(dref, tol));
1458 
1459  // exp(expression) test
1460  d3=d1+d2;
1461  dref.set_real(std::exp(d3.real()));
1462  dref.set_nonreal(d3.nonreal()*std::exp(d3.real()));
1463  d0=std::exp(d1+d2);
1464  TEST_ASSERT(d0.nearly(dref, tol));
1465 
1466  // exp(exp(expression)) test
1467  d3=d1+d2;
1468  d4.set_real(std::exp(d3.real()));
1469  d4.set_nonreal(d3.nonreal()*std::exp(d3.real()));
1470  dref.set_real(std::exp(d4.real()));
1471  dref.set_nonreal(d4.nonreal()*std::exp(d4.real()));
1472  d0=std::exp(std::exp(d1+d2));
1473  TEST_ASSERT(d0.nearly(dref, tol));
1474 
1475  // expm1(dual) test
1476  d3=d1;
1477  dref.set_real(std::expm1(d3.real()));
1478  dref.set_nonreal(d3.nonreal()*std::exp(d3.real()));
1479  d0=std::expm1(d3);
1480  TEST_ASSERT(d0.nearly(dref, tol));
1481 
1482  // expm1(expression) test
1483  d3=d1+d2;
1484  dref.set_real(std::expm1(d3.real()));
1485  dref.set_nonreal(d3.nonreal()*std::exp(d3.real()));
1486  d0=std::expm1(d1+d2);
1487  TEST_ASSERT(d0.nearly(dref, tol));
1488 
1489  // expm1(expm1(expression)) test
1490  d3=d1+d2;
1491  d4.set_real(std::expm1(d3.real()));
1492  d4.set_nonreal(d3.nonreal()*std::exp(d3.real()));
1493  dref.set_real(std::expm1(d4.real()));
1494  dref.set_nonreal(d4.nonreal()*std::exp(d4.real()));
1495  d0=std::expm1(std::expm1(d1+d2));
1496  TEST_ASSERT(d0.nearly(dref, tol));
1497 
1498  // exp2(dual) test
1499  d3=d1;
1500  dref.set_real(std::exp2(d3.real()));
1501  dref.set_nonreal(d3.nonreal()*std::log(two)*std::exp2(d3.real()));
1502  d0=std::exp2(d3);
1503  TEST_ASSERT(d0.nearly(dref, tol));
1504 
1505  // exp2(expression) test
1506  d3=d1+d2;
1507  dref.set_real(std::exp2(d3.real()));
1508  dref.set_nonreal(d3.nonreal()*std::log(two)*std::exp2(d3.real()));
1509  d0=std::exp2(d1+d2);
1510  TEST_ASSERT(d0.nearly(dref, tol));
1511 
1512  // exp2(exp2(expression)) test
1513  d3=d1+d2;
1514  d4.set_real(std::exp2(d3.real()));
1515  d4.set_nonreal(d3.nonreal()*std::log(two)*std::exp2(d3.real()));
1516  dref.set_real(std::exp2(d4.real()));
1517  dref.set_nonreal(d4.nonreal()*std::log(two)*std::exp2(d4.real()));
1518  d0=std::exp2(std::exp2(d1+d2));
1519  TEST_ASSERT(d0.nearly(dref, tol));
1520 
1521  // log(dual) test
1522  d3=d1;
1523  dref.set_real(std::log(d3.real()));
1524  dref.set_nonreal(d3.nonreal()/d3.real());
1525  d0=std::log(d3);
1526  TEST_ASSERT(d0.nearly(dref, tol));
1527 
1528  // log(expression) test
1529  d3=d1+d2;
1530  dref.set_real(std::log(d3.real()));
1531  dref.set_nonreal(d3.nonreal()/d3.real());
1532  d0=std::log(d1+d2);
1533  TEST_ASSERT(d0.nearly(dref, tol));
1534 
1535  // log(log(expression)) test
1536  d3=d1+d2;
1537  d4.set_real(std::log(d3.real()));
1538  d4.set_nonreal(d3.nonreal()/d3.real());
1539  dref.set_real(std::log(d4.real()));
1540  dref.set_nonreal(d4.nonreal()/d4.real());
1541  d0=std::log(std::log(d1+d2));
1542  TEST_ASSERT(d0.nearly(dref, tol));
1543 
1544  // log10(dual) test
1545  d3=d1;
1546  dref.set_real(std::log10(d3.real()));
1547  dref.set_nonreal(d3.nonreal()/d3.real()/std::log(ten));
1548  d0=std::log10(d3);
1549  TEST_ASSERT(d0.nearly(dref, tol));
1550 
1551  // log10(expression) test
1552  d3=d1+d2;
1553  dref.set_real(std::log10(d3.real()));
1554  dref.set_nonreal(d3.nonreal()/d3.real()/std::log(ten));
1555  d0=std::log10(d1+d2);
1556  TEST_ASSERT(d0.nearly(dref, tol));
1557 
1558  // log10(log10(expression)) test
1559  d3=d1+d2;
1560  d4.set_real(std::log10(d3.real()));
1561  d4.set_nonreal(d3.nonreal()/d3.real()/std::log(ten));
1562  dref.set_real(std::log10(d4.real()));
1563  dref.set_nonreal(d4.nonreal()/d4.real()/std::log(ten));
1564  d0=std::log10(std::log10(d1+d2));
1565  TEST_ASSERT(d0.nearly(dref, tol));
1566 
1567  // log2(dual) test
1568  d3=d1;
1569  dref.set_real(std::log2(d3.real()));
1570  dref.set_nonreal(d3.nonreal()/d3.real()/std::log(two));
1571  d0=std::log2(d3);
1572  TEST_ASSERT(d0.nearly(dref, tol));
1573 
1574  // log2(expression) test
1575  d3=d1+d2;
1576  dref.set_real(std::log2(d3.real()));
1577  dref.set_nonreal(d3.nonreal()/d3.real()/std::log(two));
1578  d0=std::log2(d1+d2);
1579  TEST_ASSERT(d0.nearly(dref, tol));
1580 
1581  // log2(log2(expression)) test
1582  d3=d1+d2;
1583  d4.set_real(std::log2(d3.real()));
1584  d4.set_nonreal(d3.nonreal()/d3.real()/std::log(two));
1585  dref.set_real(std::log2(d4.real()));
1586  dref.set_nonreal(d4.nonreal()/d4.real()/std::log(two));
1587  d0=std::log2(std::log2(d1+d2));
1588  TEST_ASSERT(d0.nearly(dref, tol));
1589 
1590  // log1p(dual) test
1591  d3=d1;
1592  dref.set_real(std::log1p(d3.real()));
1593  dref.set_nonreal(d3.nonreal()/(1+d3.real()));
1594  d0=std::log1p(d3);
1595  TEST_ASSERT(d0.nearly(dref, tol));
1596 
1597  // log1p(expression) test
1598  d3=d1+d2;
1599  dref.set_real(std::log1p(d3.real()));
1600  dref.set_nonreal(d3.nonreal()/(1+d3.real()));
1601  d0=std::log1p(d1+d2);
1602  TEST_ASSERT(d0.nearly(dref, tol));
1603 
1604  // log1p(log1p(expression)) test
1605  d3=d1+d2;
1606  d4.set_real(std::log1p(d3.real()));
1607  d4.set_nonreal(d3.nonreal()/(1+d3.real()));
1608  dref.set_real(std::log1p(d4.real()));
1609  dref.set_nonreal(d4.nonreal()/(1+d4.real()));
1610  d0=std::log1p(std::log1p(d1+d2));
1611  TEST_ASSERT(d0.nearly(dref, tol));
1612  }
1613 
1615  {
1616  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1617  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon())), two(2), ten(10);
1618 
1619  // exp(dual) test
1620  d3=d1;
1621  dref.set_real(exp(d3.real()));
1622  dref.set_nonreal(d3.nonreal()*exp(d3.real()));
1623  d0=exp(d3);
1624  TEST_ASSERT(d0.nearly(dref, tol));
1625 
1626  // exp(expression) test
1627  d3=d1+d2;
1628  dref.set_real(exp(d3.real()));
1629  dref.set_nonreal(d3.nonreal()*exp(d3.real()));
1630  d0=exp(d1+d2);
1631  TEST_ASSERT(d0.nearly(dref, tol));
1632 
1633  // exp(exp(expression)) test
1634  d3=d1+d2;
1635  d4.set_real(exp(d3.real()));
1636  d4.set_nonreal(d3.nonreal()*exp(d3.real()));
1637  dref.set_real(exp(d4.real()));
1638  dref.set_nonreal(d4.nonreal()*exp(d4.real()));
1639  d0=exp(exp(d1+d2));
1640  TEST_ASSERT(d0.nearly(dref, tol));
1641 
1642  // expm1(dual) test
1643  d3=d1;
1644  dref.set_real(expm1(d3.real()));
1645  dref.set_nonreal(d3.nonreal()*exp(d3.real()));
1646  d0=expm1(d3);
1647  TEST_ASSERT(d0.nearly(dref, tol));
1648 
1649  // expm1(expression) test
1650  d3=d1+d2;
1651  dref.set_real(expm1(d3.real()));
1652  dref.set_nonreal(d3.nonreal()*exp(d3.real()));
1653  d0=expm1(d1+d2);
1654  TEST_ASSERT(d0.nearly(dref, tol));
1655 
1656  // expm1(expm1(expression)) test
1657  d3=d1+d2;
1658  d4.set_real(expm1(d3.real()));
1659  d4.set_nonreal(d3.nonreal()*exp(d3.real()));
1660  dref.set_real(expm1(d4.real()));
1661  dref.set_nonreal(d4.nonreal()*exp(d4.real()));
1662  d0=expm1(expm1(d1+d2));
1663  TEST_ASSERT(d0.nearly(dref, tol));
1664 
1665  // exp2(dual) test
1666  d3=d1;
1667  dref.set_real(exp2(d3.real()));
1668  dref.set_nonreal(d3.nonreal()*log(two)*exp2(d3.real()));
1669  d0=exp2(d3);
1670  TEST_ASSERT(d0.nearly(dref, tol));
1671 
1672  // exp2(expression) test
1673  d3=d1+d2;
1674  dref.set_real(exp2(d3.real()));
1675  dref.set_nonreal(d3.nonreal()*log(two)*exp2(d3.real()));
1676  d0=exp2(d1+d2);
1677  TEST_ASSERT(d0.nearly(dref, tol));
1678 
1679  // exp2(exp2(expression)) test
1680  d3=d1+d2;
1681  d4.set_real(exp2(d3.real()));
1682  d4.set_nonreal(d3.nonreal()*log(two)*exp2(d3.real()));
1683  dref.set_real(exp2(d4.real()));
1684  dref.set_nonreal(d4.nonreal()*log(two)*exp2(d4.real()));
1685  d0=exp2(exp2(d1+d2));
1686  TEST_ASSERT(d0.nearly(dref, tol));
1687 
1688  // log(dual) test
1689  d3=d1;
1690  dref.set_real(log(d3.real()));
1691  dref.set_nonreal(d3.nonreal()/d3.real());
1692  d0=log(d3);
1693  TEST_ASSERT(d0.nearly(dref, tol));
1694 
1695  // log(expression) test
1696  d3=d1+d2;
1697  dref.set_real(log(d3.real()));
1698  dref.set_nonreal(d3.nonreal()/d3.real());
1699  d0=log(d1+d2);
1700  TEST_ASSERT(d0.nearly(dref, tol));
1701 
1702  // log(log(expression)) test
1703  d3=d1+d2;
1704  d4.set_real(log(d3.real()));
1705  d4.set_nonreal(d3.nonreal()/d3.real());
1706  dref.set_real(log(d4.real()));
1707  dref.set_nonreal(d4.nonreal()/d4.real());
1708  d0=log(log(d1+d2));
1709  TEST_ASSERT(d0.nearly(dref, tol));
1710 
1711  // log10(dual) test
1712  d3=d1;
1713  dref.set_real(log10(d3.real()));
1714  dref.set_nonreal(d3.nonreal()/d3.real()/log(ten));
1715  d0=log10(d3);
1716  TEST_ASSERT(d0.nearly(dref, tol));
1717 
1718  // log10(expression) test
1719  d3=d1+d2;
1720  dref.set_real(log10(d3.real()));
1721  dref.set_nonreal(d3.nonreal()/d3.real()/log(ten));
1722  d0=log10(d1+d2);
1723  TEST_ASSERT(d0.nearly(dref, tol));
1724 
1725  // log10(log10(expression)) test
1726  d3=d1+d2;
1727  d4.set_real(log10(d3.real()));
1728  d4.set_nonreal(d3.nonreal()/d3.real()/log(ten));
1729  dref.set_real(log10(d4.real()));
1730  dref.set_nonreal(d4.nonreal()/d4.real()/log(ten));
1731  d0=log10(log10(d1+d2));
1732  TEST_ASSERT(d0.nearly(dref, tol));
1733 
1734  // log2(dual) test
1735  d3=d1;
1736  dref.set_real(log2(d3.real()));
1737  dref.set_nonreal(d3.nonreal()/d3.real()/log(two));
1738  d0=log2(d3);
1739  TEST_ASSERT(d0.nearly(dref, tol));
1740 
1741  // log2(expression) test
1742  d3=d1+d2;
1743  dref.set_real(log2(d3.real()));
1744  dref.set_nonreal(d3.nonreal()/d3.real()/log(two));
1745  d0=log2(d1+d2);
1746  TEST_ASSERT(d0.nearly(dref, tol));
1747 
1748  // log2(log2(expression)) test
1749  d3=d1+d2;
1750  d4.set_real(log2(d3.real()));
1751  d4.set_nonreal(d3.nonreal()/d3.real()/log(two));
1752  dref.set_real(log2(d4.real()));
1753  dref.set_nonreal(d4.nonreal()/d4.real()/log(two));
1754  d0=log2(log2(d1+d2));
1755  TEST_ASSERT(d0.nearly(dref, tol));
1756 
1757  // log1p(dual) test
1758  d3=d1;
1759  dref.set_real(log1p(d3.real()));
1760  dref.set_nonreal(d3.nonreal()/(1+d3.real()));
1761  d0=log1p(d3);
1762  TEST_ASSERT(d0.nearly(dref, tol));
1763 
1764  // log1p(expression) test
1765  d3=d1+d2;
1766  dref.set_real(log1p(d3.real()));
1767  dref.set_nonreal(d3.nonreal()/(1+d3.real()));
1768  d0=log1p(d1+d2);
1769  TEST_ASSERT(d0.nearly(dref, tol));
1770 
1771  // log1p(log1p(expression)) test
1772  d3=d1+d2;
1773  d4.set_real(log1p(d3.real()));
1774  d4.set_nonreal(d3.nonreal()/(1+d3.real()));
1775  dref.set_real(log1p(d4.real()));
1776  dref.set_nonreal(d4.nonreal()/(1+d4.real()));
1777  d0=log1p(log1p(d1+d2));
1778  TEST_ASSERT(d0.nearly(dref, tol));
1779  }
1780 
1782  {
1783  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1784  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1785 
1786  // sqrt(dual) test
1787  d3=d1;
1788  dref.set_real(std::sqrt(d3.real()));
1789  dref.set_nonreal(d3.nonreal()/std::sqrt(d3.real())/2);
1790  d0=std::sqrt(d3);
1791  TEST_ASSERT(d0.nearly(dref, tol));
1792 
1793  // sqrt(expression) test
1794  d3=d1+d2;
1795  dref.set_real(std::sqrt(d3.real()));
1796  dref.set_nonreal(d3.nonreal()/std::sqrt(d3.real())/2);
1797  d0=std::sqrt(d1+d2);
1798  TEST_ASSERT(d0.nearly(dref, tol));
1799 
1800  // sqrt(sqrt(expression)) test
1801  d3=d1+d2;
1802  d4.set_real(std::sqrt(d3.real()));
1803  d4.set_nonreal(d3.nonreal()/std::sqrt(d3.real())/2);
1804  dref.set_real(std::sqrt(d4.real()));
1805  dref.set_nonreal(d4.nonreal()/std::sqrt(d4.real())/2);
1806  d0=std::sqrt(std::sqrt(d1+d2));
1807  TEST_ASSERT(d0.nearly(dref, tol));
1808 
1809  // cbrt(dual) test
1810  d3=d1;
1811  dref.set_real(std::cbrt(d3.real()));
1812  dref.set_nonreal(d3.nonreal()/std::cbrt(d3.real()*d3.real())/3);
1813  d0=std::cbrt(d3);
1814  TEST_ASSERT(d0.nearly(dref, tol));
1815 
1816  // cbrt(expression) test
1817  d3=d1+d2;
1818  dref.set_real(std::cbrt(d3.real()));
1819  dref.set_nonreal(d3.nonreal()/std::cbrt(d3.real()*d3.real())/3);
1820  d0=std::cbrt(d1+d2);
1821  TEST_ASSERT(d0.nearly(dref, tol));
1822 
1823  // cbrt(cbrt(expression)) test
1824  d3=d1+d2;
1825  d4.set_real(std::cbrt(d3.real()));
1826  d4.set_nonreal(d3.nonreal()/std::cbrt(d3.real()*d3.real())/3);
1827  dref.set_real(std::cbrt(d4.real()));
1828  dref.set_nonreal(d4.nonreal()/std::cbrt(d4.real()*d4.real())/3);
1829  d0=std::cbrt(std::cbrt(d1+d2));
1830  TEST_ASSERT(d0.nearly(dref, tol));
1831 
1832  // TODO: ADD hypot test when bin_fun implemented
1833 
1834  // TODO: ADD pow test when bin_fun implemented
1835  }
1836 
1838  {
1839  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1840  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1841 
1842  // sqrt(dual) test
1843  d3=d1;
1844  dref.set_real(sqrt(d3.real()));
1845  dref.set_nonreal(d3.nonreal()/sqrt(d3.real())/2);
1846  d0=sqrt(d3);
1847  TEST_ASSERT(d0.nearly(dref, tol));
1848 
1849  // sqrt(expression) test
1850  d3=d1+d2;
1851  dref.set_real(sqrt(d3.real()));
1852  dref.set_nonreal(d3.nonreal()/sqrt(d3.real())/2);
1853  d0=sqrt(d1+d2);
1854  TEST_ASSERT(d0.nearly(dref, tol));
1855 
1856  // sqrt(sqrt(expression)) test
1857  d3=d1+d2;
1858  d4.set_real(sqrt(d3.real()));
1859  d4.set_nonreal(d3.nonreal()/sqrt(d3.real())/2);
1860  dref.set_real(sqrt(d4.real()));
1861  dref.set_nonreal(d4.nonreal()/sqrt(d4.real())/2);
1862  d0=sqrt(sqrt(d1+d2));
1863  TEST_ASSERT(d0.nearly(dref, tol));
1864 
1865  // cbrt(dual) test
1866  d3=d1;
1867  dref.set_real(cbrt(d3.real()));
1868  dref.set_nonreal(d3.nonreal()/cbrt(d3.real()*d3.real())/3);
1869  d0=cbrt(d3);
1870  TEST_ASSERT(d0.nearly(dref, tol));
1871 
1872  // cbrt(expression) test
1873  d3=d1+d2;
1874  dref.set_real(cbrt(d3.real()));
1875  dref.set_nonreal(d3.nonreal()/cbrt(d3.real()*d3.real())/3);
1876  d0=cbrt(d1+d2);
1877  TEST_ASSERT(d0.nearly(dref, tol));
1878 
1879  // cbrt(cbrt(expression)) test
1880  d3=d1+d2;
1881  d4.set_real(cbrt(d3.real()));
1882  d4.set_nonreal(d3.nonreal()/cbrt(d3.real()*d3.real())/3);
1883  dref.set_real(cbrt(d4.real()));
1884  dref.set_nonreal(d4.nonreal()/cbrt(d4.real()*d4.real())/3);
1885  d0=cbrt(cbrt(d1+d2));
1886  TEST_ASSERT(d0.nearly(dref, tol));
1887 
1888  // TODO: ADD hypot test when bin_fun implemented
1889 
1890  // TODO: ADD pow test when bin_fun implemented
1891  }
1892 
1894  {
1895  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1896  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1897 
1898  // abs(dual) test
1899  d3=d1;
1900  dref.set_real(std::abs(d3.real()));
1901  dref.set_nonreal(d3.nonreal()*((d3.real()<0)?(-1):(1)));
1902  d0=std::abs(d3);
1903  TEST_ASSERT(d0.nearly(dref, tol));
1904 
1905  // abs(expression) test
1906  d3=d1+d2;
1907  dref.set_real(std::abs(d3.real()));
1908  dref.set_nonreal(d3.nonreal()*((d3.real()<0)?(-1):(1)));
1909  d0=std::abs(d1+d2);
1910  TEST_ASSERT(d0.nearly(dref, tol));
1911 
1912  // abs(abs(expression)) test
1913  d3=d1+d2;
1914  d4.set_real(std::abs(d3.real()));
1915  d4.set_nonreal(d3.nonreal()*((d3.real()<0)?(-1):(1)));
1916  dref.set_real(std::abs(d4.real()));
1917  dref.set_nonreal(d4.nonreal()*((d4.real()<0)?(-1):(1)));
1918  d0=std::abs(std::abs(d1+d2));
1919  TEST_ASSERT(d0.nearly(dref, tol));
1920 
1921  // ceil(dual) test
1922  d3=d1;
1923  dref.set_real(std::ceil(d3.real()));
1924  dref.set_nonreal(d3.nonreal()*(0));
1925  d0=std::ceil(d3);
1926  TEST_ASSERT(d0.nearly(dref, tol));
1927 
1928  // ceil(expression) test
1929  d3=d1+d2;
1930  dref.set_real(std::ceil(d3.real()));
1931  dref.set_nonreal(d3.nonreal()*(0));
1932  d0=std::ceil(d1+d2);
1933  TEST_ASSERT(d0.nearly(dref, tol));
1934 
1935  // ceil(ceil(expression)) test
1936  d3=d1+d2;
1937  d4.set_real(std::ceil(d3.real()));
1938  d4.set_nonreal(d3.nonreal()*(0));
1939  dref.set_real(std::ceil(d4.real()));
1940  dref.set_nonreal(d4.nonreal()*(0));
1941  d0=std::ceil(std::ceil(d1+d2));
1942  TEST_ASSERT(d0.nearly(dref, tol));
1943 
1944  // floor(dual) test
1945  d3=d1;
1946  dref.set_real(std::floor(d3.real()));
1947  dref.set_nonreal(d3.nonreal()*(0));
1948  d0=std::floor(d3);
1949  TEST_ASSERT(d0.nearly(dref, tol));
1950 
1951  // floor(expression) test
1952  d3=d1+d2;
1953  dref.set_real(std::floor(d3.real()));
1954  dref.set_nonreal(d3.nonreal()*(0));
1955  d0=std::floor(d1+d2);
1956  TEST_ASSERT(d0.nearly(dref, tol));
1957 
1958  // floor(floor(expression)) test
1959  d3=d1+d2;
1960  d4.set_real(std::floor(d3.real()));
1961  d4.set_nonreal(d3.nonreal()*(0));
1962  dref.set_real(std::floor(d4.real()));
1963  dref.set_nonreal(d4.nonreal()*(0));
1964  d0=std::floor(std::floor(d1+d2));
1965  TEST_ASSERT(d0.nearly(dref, tol));
1966 
1967  // TODO: ADD fmod test when bin_fun implemented
1968 
1969  // TODO: ADD fmin test when bin_fun implemented
1970 
1971  // TODO: ADD fmax test when bin_fun implemented
1972 
1973  // TODO: ADD min test when bin_fun implemented
1974 
1975  // TODO: ADD max test when bin_fun implemented
1976 
1977  // TODO: ADD modf test when bin_fun implemented
1978 
1979  // TODO: ADD ldexp test when bin_fun implemented
1980  }
1981 
1983  {
1984  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
1985  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
1986 
1987  // abs(dual) test
1988  d3=d1;
1989  dref.set_real(abs(d3.real()));
1990  dref.set_nonreal(d3.nonreal()*((d3.real()<0)?(-1):(1)));
1991  d0=abs(d3);
1992  TEST_ASSERT(d0.nearly(dref, tol));
1993 
1994  // abs(expression) test
1995  d3=d1+d2;
1996  dref.set_real(abs(d3.real()));
1997  dref.set_nonreal(d3.nonreal()*((d3.real()<0)?(-1):(1)));
1998  d0=abs(d1+d2);
1999  TEST_ASSERT(d0.nearly(dref, tol));
2000 
2001  // abs(abs(expression)) test
2002  d3=d1+d2;
2003  d4.set_real(abs(d3.real()));
2004  d4.set_nonreal(d3.nonreal()*((d3.real()<0)?(-1):(1)));
2005  dref.set_real(abs(d4.real()));
2006  dref.set_nonreal(d4.nonreal()*((d4.real()<0)?(-1):(1)));
2007  d0=abs(abs(d1+d2));
2008  TEST_ASSERT(d0.nearly(dref, tol));
2009 
2010  // ceil(dual) test
2011  d3=d1;
2012  dref.set_real(ceil(d3.real()));
2013  dref.set_nonreal(d3.nonreal()*(0));
2014  d0=ceil(d3);
2015  TEST_ASSERT(d0.nearly(dref, tol));
2016 
2017  // ceil(expression) test
2018  d3=d1+d2;
2019  dref.set_real(ceil(d3.real()));
2020  dref.set_nonreal(d3.nonreal()*(0));
2021  d0=ceil(d1+d2);
2022  TEST_ASSERT(d0.nearly(dref, tol));
2023 
2024  // ceil(ceil(expression)) test
2025  d3=d1+d2;
2026  d4.set_real(ceil(d3.real()));
2027  d4.set_nonreal(d3.nonreal()*(0));
2028  dref.set_real(ceil(d4.real()));
2029  dref.set_nonreal(d4.nonreal()*(0));
2030  d0=ceil(ceil(d1+d2));
2031  TEST_ASSERT(d0.nearly(dref, tol));
2032 
2033  // floor(dual) test
2034  d3=d1;
2035  dref.set_real(floor(d3.real()));
2036  dref.set_nonreal(d3.nonreal()*(0));
2037  d0=floor(d3);
2038  TEST_ASSERT(d0.nearly(dref, tol));
2039 
2040  // floor(expression) test
2041  d3=d1+d2;
2042  dref.set_real(floor(d3.real()));
2043  dref.set_nonreal(d3.nonreal()*(0));
2044  d0=floor(d1+d2);
2045  TEST_ASSERT(d0.nearly(dref, tol));
2046 
2047  // floor(floor(expression)) test
2048  d3=d1+d2;
2049  d4.set_real(floor(d3.real()));
2050  d4.set_nonreal(d3.nonreal()*(0));
2051  dref.set_real(floor(d4.real()));
2052  dref.set_nonreal(d4.nonreal()*(0));
2053  d0=floor(floor(d1+d2));
2054  TEST_ASSERT(d0.nearly(dref, tol));
2055 
2056  // TODO: ADD fmod test when bin_fun implemented
2057 
2058  // TODO: ADD fmin test when bin_fun implemented
2059 
2060  // TODO: ADD fmax test when bin_fun implemented
2061 
2062  // TODO: ADD min test when bin_fun implemented
2063 
2064  // TODO: ADD max test when bin_fun implemented
2065 
2066  // TODO: ADD modf test when bin_fun implemented
2067 
2068  // TODO: ADD ldexp test when bin_fun implemented
2069  }
2070 
2072  {
2073  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
2074  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
2075 
2076  // erf(dual) test
2077  d3=d1;
2078  dref.set_real(std::erf(d3.real()));
2079  dref.set_nonreal(d3.nonreal()*(2*std::exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2080  d0=std::erf(d3);
2081  TEST_ASSERT(d0.nearly(dref, tol));
2082 
2083  // erf(expression) test
2084  d3=d1+d2;
2085  dref.set_real(std::erf(d3.real()));
2086  dref.set_nonreal(d3.nonreal()*(2*std::exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2087  d0=std::erf(d1+d2);
2088  TEST_ASSERT(d0.nearly(dref, tol));
2089 
2090  // erf(erf(expression)) test
2091  d3=d1+d2;
2092  d4.set_real(std::erf(d3.real()));
2093  d4.set_nonreal(d3.nonreal()*(2*std::exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2094  dref.set_real(std::erf(d4.real()));
2095  dref.set_nonreal(d4.nonreal()*(2*std::exp(-d4.real()*d4.real())/eli::constants::math<data__>::sqrt_pi()));
2096  d0=std::erf(std::erf(d1+d2));
2097  TEST_ASSERT(d0.nearly(dref, tol));
2098 
2099  // erfc(dual) test
2100  d3=d1;
2101  dref.set_real(std::erfc(d3.real()));
2102  dref.set_nonreal(d3.nonreal()*(-2*std::exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2103  d0=std::erfc(d3);
2104  TEST_ASSERT(d0.nearly(dref, tol));
2105 
2106  // erfc(expression) test
2107  d3=d1+d2;
2108  dref.set_real(std::erfc(d3.real()));
2109  dref.set_nonreal(d3.nonreal()*(-2*std::exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2110  d0=std::erfc(d1+d2);
2111  TEST_ASSERT(d0.nearly(dref, tol));
2112 
2113  // erfc(erfc(expression)) test
2114  d3=d1+d2;
2115  d4.set_real(std::erfc(d3.real()));
2116  d4.set_nonreal(d3.nonreal()*(-2*std::exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2117  dref.set_real(std::erfc(d4.real()));
2118  dref.set_nonreal(d4.nonreal()*(-2*std::exp(-d4.real()*d4.real())/eli::constants::math<data__>::sqrt_pi()));
2119  d0=std::erfc(std::erfc(d1+d2));
2120  TEST_ASSERT(d0.nearly(dref, tol));
2121  }
2122 
2124  {
2125  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
2126  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
2127 
2128  // erf(dual) test
2129  d3=d1;
2130  dref.set_real(erf(d3.real()));
2131  dref.set_nonreal(d3.nonreal()*(2*exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2132  d0=erf(d3);
2133  TEST_ASSERT(d0.nearly(dref, tol));
2134 
2135  // erf(expression) test
2136  d3=d1+d2;
2137  dref.set_real(erf(d3.real()));
2138  dref.set_nonreal(d3.nonreal()*(2*exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2139  d0=erf(d1+d2);
2140  TEST_ASSERT(d0.nearly(dref, tol));
2141 
2142  // erf(erf(expression)) test
2143  d3=d1+d2;
2144  d4.set_real(erf(d3.real()));
2145  d4.set_nonreal(d3.nonreal()*(2*exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2146  dref.set_real(erf(d4.real()));
2147  dref.set_nonreal(d4.nonreal()*(2*exp(-d4.real()*d4.real())/eli::constants::math<data__>::sqrt_pi()));
2148  d0=erf(erf(d1+d2));
2149  TEST_ASSERT(d0.nearly(dref, tol));
2150 
2151  // erfc(dual) test
2152  d3=d1;
2153  dref.set_real(erfc(d3.real()));
2154  dref.set_nonreal(d3.nonreal()*(-2*exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2155  d0=erfc(d3);
2156  TEST_ASSERT(d0.nearly(dref, tol));
2157 
2158  // erfc(expression) test
2159  d3=d1+d2;
2160  dref.set_real(erfc(d3.real()));
2161  dref.set_nonreal(d3.nonreal()*(-2*exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2162  d0=erfc(d1+d2);
2163  TEST_ASSERT(d0.nearly(dref, tol));
2164 
2165  // erfc(erfc(expression)) test
2166  d3=d1+d2;
2167  d4.set_real(erfc(d3.real()));
2168  d4.set_nonreal(d3.nonreal()*(-2*exp(-d3.real()*d3.real())/eli::constants::math<data__>::sqrt_pi()));
2169  dref.set_real(erfc(d4.real()));
2170  dref.set_nonreal(d4.nonreal()*(-2*exp(-d4.real()*d4.real())/eli::constants::math<data__>::sqrt_pi()));
2171  d0=erfc(erfc(d1+d2));
2172  TEST_ASSERT(d0.nearly(dref, tol));
2173  }
2174 
2175  // error & gamma functions: lgamma, tgamma
2176 
2178  {
2179  // TODO: ADD lgamma test when know how to implement derivative
2180 
2181  // TODO: ADD tgamma test when know how to implement derivative
2182 #if 0
2183  eli::mutil::ad::dual<data__, false> d1(2,-2), d2(2,3), d3, d4, d0, dref;
2184  data__ tol(std::sqrt(std::numeric_limits<data__>::epsilon()));
2185 
2186  // lgamma(dual) test
2187  d3=d1;
2188  dref.set_real(std::lgamma(d3.real()));
2189  dref.set_nonreal(d3.nonreal()*(xxx));
2190  d0=std::lgamma(d3);
2191  TEST_ASSERT(d0.nearly(dref, tol));
2192 
2193  // lgamma(expression) test
2194  d3=d1+d2;
2195  dref.set_real(std::lgamma(d3.real()));
2196  dref.set_nonreal(d3.nonreal()*(xxx));
2197  d0=std::lgamma(d1+d2);
2198  TEST_ASSERT(d0.nearly(dref, tol));
2199 
2200  // lgamma(lgamma(expression)) test
2201  d3=d1+d2;
2202  d4.set_real(std::lgamma(d3.real()));
2203  d4.set_nonreal(d3.nonreal()*(xxx));
2204  dref.set_real(std::lgamma(d4.real()));
2205  dref.set_nonreal(d4.nonreal()*(xxx));
2206  d0=std::erf(std::lgamma(d1+d2));
2207  TEST_ASSERT(d0.nearly(dref, tol));
2208 
2209  // erfc(dual) test
2210  d3=d1;
2211  dref.set_real(std::erfc(d3.real()));
2212  dref.set_nonreal(d3.nonreal()*(xxx));
2213  d0=std::erfc(d3);
2214  TEST_ASSERT(d0.nearly(dref, tol));
2215 
2216  // erfc(expression) test
2217  d3=d1+d2;
2218  dref.set_real(std::erfc(d3.real()));
2219  dref.set_nonreal(d3.nonreal()*(xxx));
2220  d0=std::erfc(d1+d2);
2221  TEST_ASSERT(d0.nearly(dref, tol));
2222 
2223  // erfc(erfc(expression)) test
2224  d3=d1+d2;
2225  d4.set_real(std::erfc(d3.real()));
2226  d4.set_nonreal(d3.nonreal()*(xxx));
2227  dref.set_real(std::erfc(d4.real()));
2228  dref.set_nonreal(d4.nonreal()*(xxx));
2229  d0=std::erfc(std::erfc(d1+d2));
2230  TEST_ASSERT(d0.nearly(dref, tol));
2231 #endif
2232  }
2233 
2235  {
2236  // TODO: ADD lgamma test when know how to implement derivative
2237 
2238  // TODO: ADD tgamma test when know how to implement derivative
2239  }
2240 
2241  // TODO: Implement text write
2242  // TODO: Implement binary read
2243  // TODO: Implement binary write
2244 };
2245 
2246 #endif
2247 
void dual_division_test()
Definition: ad_dual_test_suite.hpp:767
void dual_hyp_trig_nostd_test()
Definition: ad_dual_test_suite.hpp:1304
void dual_exp_test()
Definition: ad_dual_test_suite.hpp:1447
void dual_assignment_test()
Definition: ad_dual_test_suite.hpp:117
void dual_trig_test()
Definition: ad_dual_test_suite.hpp:886
void dual_erf_nostd_test()
Definition: ad_dual_test_suite.hpp:2123
void dual_gamma_test()
Definition: ad_dual_test_suite.hpp:2177
void set_nonreal(const data_type &nr)
Definition: dual_number.hpp:315
void dual_subtraction_test()
Definition: ad_dual_test_suite.hpp:545
void dual_power_nostd_test()
Definition: ad_dual_test_suite.hpp:1837
void AddTests(const float &)
Definition: ad_dual_test_suite.hpp:31
void dual_misc_test()
Definition: ad_dual_test_suite.hpp:1893
ad_dual_test_suite()
Definition: ad_dual_test_suite.hpp:107
data_type nonreal() const
Definition: dual_number.hpp:313
void dual_misc_nostd_test()
Definition: ad_dual_test_suite.hpp:1982
Definition: math.hpp:25
data_type real() const
Definition: dual_number.hpp:312
Definition: ad_dual_test_suite.hpp:28
void AddTests(const double &)
Definition: ad_dual_test_suite.hpp:56
bool exact(const data_type &d) const
Definition: dual_number.hpp:513
bool nearly(const data_type &d, const data_type &eps) const
Definition: dual_number.hpp:537
void set_real(const data_type &r)
Definition: dual_number.hpp:314
void dual_exact_comparison_test()
Definition: ad_dual_test_suite.hpp:148
void dual_trig_nostd_test()
Definition: ad_dual_test_suite.hpp:1023
void AddTests(const long double &)
Definition: ad_dual_test_suite.hpp:81
void dual_hyp_trig_test()
Definition: ad_dual_test_suite.hpp:1161
Definition: dual_number.hpp:28
void dual_addition_test()
Definition: ad_dual_test_suite.hpp:438
void dual_power_test()
Definition: ad_dual_test_suite.hpp:1781
void dual_multiplication_test()
Definition: ad_dual_test_suite.hpp:652
void dual_exp_nostd_test()
Definition: ad_dual_test_suite.hpp:1614
void dual_gamma_nostd_test()
Definition: ad_dual_test_suite.hpp:2234
void dual_erf_test()
Definition: ad_dual_test_suite.hpp:2071
void dual_inexact_comparison_test()
Definition: ad_dual_test_suite.hpp:210
~ad_dual_test_suite()
Definition: ad_dual_test_suite.hpp:112