Code-Eli  0.3.6
dual_number.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 eli_mutil_ad_dual_number_hpp
14 #define eli_mutil_ad_dual_number_hpp
15 
16 #include "eli/code_eli.hpp"
17 
18 //
19 // dual value type
20 //
21 namespace eli
22 {
23  namespace mutil
24  {
25  namespace ad
26  {
27  // forward declare dual
28  template<typename data__, bool comp_real_only> class dual;
29 
30  namespace dual_number
31  {
32  //
33  // constant type
34  //
35  template <typename data__>
36  class constant
37  {
38  public:
39  typedef data__ data_type;
40 
41  private:
42  const data_type & val;
43 
44  public:
45  constant(const data_type &v) : val(v) {}
46 
47  data_type real() const {return val;}
48  data_type nonreal() const {return 0;}
49  };
50 
51  //
52  // expression type
53  //
54  template <typename T__, bool comp_real_only>
55  class expression
56  {
57  private:
58  const T__ expr;
59 
60  public:
61  typedef typename T__::data_type data_type;
62 
63  explicit expression(const T__ &e) : expr(e) {}
64 
65  const data_type real() const {return expr.real();}
66  const data_type nonreal() const {return expr.nonreal();}
67 
68  // operator==
69  bool operator==(const data_type &v) const
70  {
72  return d==v;
73  }
75  {
76  eli::mutil::ad::dual<data_type, comp_real_only> dl(this->real(), this->nonreal()), dr(e.real(), e.nonreal());
77  return dl==dr;
78  }
79 
80  // operator==
81  bool operator!=(const data_type &v) const
82  {
83  return !operator==(v);
84  }
86  {
87  return !operator==(e);
88  }
89 
90  // operator<=
91  bool operator<=(const data_type &v) const
92  {
94  return d<=v;
95  }
96  bool operator<=(const expression<T__, comp_real_only> &e) const
97  {
98  eli::mutil::ad::dual<data_type, comp_real_only> dl(this->real(), this->nonreal()), dr(e.real(), e.nonreal());
99  return dl<=dr;
100  }
101 
102  // operator<
103  bool operator<(const data_type &v) const
104  {
106  return d<v;
107  }
108  bool operator<(const expression<T__, comp_real_only> &e) const
109  {
110  eli::mutil::ad::dual<data_type, comp_real_only> dl(this->real(), this->nonreal()), dr(e.real(), e.nonreal());
111  return dl<dr;
112  }
113 
114  // operator>=
115  bool operator>=(const data_type &v) const
116  {
118  return d>=v;
119  }
121  {
122  eli::mutil::ad::dual<data_type, comp_real_only> dl(this->real(), this->nonreal()), dr(e.real(), e.nonreal());
123  return dl>=dr;
124  }
125 
126  // operator>
127  bool operator>(const data_type &v) const
128  {
130  return d>v;
131  }
133  {
134  eli::mutil::ad::dual<data_type, comp_real_only> dl(this->real(), this->nonreal()), dr(e.real(), e.nonreal());
135  return dl>dr;
136  }
137  };
138  }
139  }
140  }
141 }
142 
143 // comparison operators
144 #ifdef _MSC_VER
145 # pragma warning(push)
146 # pragma warning(disable: 4244)
147 #endif
148 template <typename data2__, typename data__, bool comp_real_only>
150 {
151  return e==v;
152 }
153 template <typename data2__, typename data__, bool comp_real_only>
155 {
156  return e!=v;
157 }
158 template <typename data2__, typename data__, bool comp_real_only>
159 bool operator<=(const data2__ &v, const eli::mutil::ad::dual_number::expression<data__, comp_real_only> &e)
160 {
161  return e>=v;
162 }
163 template <typename data2__, typename data__, bool comp_real_only>
164 bool operator<(const data2__ &v, const eli::mutil::ad::dual_number::expression<data__, comp_real_only> &e)
165 {
166  return e>v;
167 }
168 template <typename data2__, typename data__, bool comp_real_only>
170 {
171  return e<=v;
172 }
173 template <typename data2__, typename data__, bool comp_real_only>
175 {
176  return e<v;
177 }
178 #ifdef _MSC_VER
179 # pragma warning(pop)
180 #endif
181 
182 namespace eli
183 {
184  namespace mutil
185  {
186  namespace ad
187  {
188  template <typename data__, bool comp_real_only>
189  class dual
190  {
191  public:
192  typedef data__ data_type;
193 
194  private:
195  data__ val[2];
196 
197  private:
198  bool exact_equiv(const data__ &r, const data__ &nr) const
199  {
200  if (val[0]!=r)
201  return false;
202  if (val[1]!=nr)
203  return false;
204  return true;
205  }
206  bool nearly_equiv(const data__ &r, const data__ &nr, const data__ &eps) const
207  {
208  data__ rdif(val[0]-r), nrdif(val[1]-nr);
209  if (std::abs(rdif)>eps)
210  return false;
211  if (std::abs(nrdif)>eps)
212  return false;
213  return true;
214  }
215 
216  bool exact_less_than(const data__ &/*r*/, const data__ &/*nr*/) const
217  {
218  // not implemented
219  assert(false);
220  return false;
221  }
222 
223  bool exact_less_than_equal(const data__ &/*r*/, const data__ &/*nr*/) const
224  {
225  // not implemented
226  assert(false);
227  return false;
228  }
229 
230  bool exact_greater_than(const data__ &/*r*/, const data__ &/*nr*/) const
231  {
232  // not implemented
233  assert(false);
234  return false;
235  }
236 
237  bool exact_greater_than_equal(const data__ &/*r*/, const data__ &/*nr*/) const
238  {
239  // not implemented
240  assert(false);
241  return false;
242  }
243 
244  bool inexact_equiv(const data__ &r) const
245  {
246  return val[0]==r;
247  }
248 
249  bool inexact_less_than(const data__ &r) const
250  {
251  return val[0]<r;
252  }
253 
254  bool inexact_less_than_equal(const data__ &r) const
255  {
256  return val[0]<=r;
257  }
258 
259  bool inexact_greater_than(const data__ &r) const
260  {
261  return val[0]>r;
262  }
263 
264  bool inexact_greater_than_equal(const data__ &r) const
265  {
266  return val[0]>=r;
267  }
268 
269  public:
271  {
272  #ifdef DEBUG
273  val[0]=static_cast<data_type>(0);
274  val[1]=static_cast<data_type>(0);
275  #endif
276  }
277 
278  explicit dual(const data__ &v)
279  {
280  val[0]=v;
281  val[1]=static_cast<data_type>(0);
282  }
283 
284  dual(const data_type &v1, const data_type &v2)
285  {
286  val[0]=v1;
287  val[1]=v2;
288  }
289 
291  {
292  val[0]=d.real();
293  val[1]=d.nonreal();
294  }
295 
296  template<typename data2__>
298  {
299  val[0]=c.real();
300  val[1]=c.nonreal();
301  }
302 
303  template<typename data2__>
305  {
306  val[0]=c.real();
307  val[1]=c.nonreal();
308  }
309 
310  ~dual() {}
311 
312  data_type real() const {return val[0];}
313  data_type nonreal() const {return val[1];}
314  void set_real(const data_type &r) {val[0]=r;}
315  void set_nonreal(const data_type &nr) {val[1]=nr;}
316 
318  {
319  val[0]=v;
320  val[1]=static_cast<data_type>(0);
321  return *this;
322  }
323 
325  {
326  if (this!=&d)
327  {
328  val[0]=d.real();
329  val[1]=d.nonreal();
330  }
331 
332  return *this;
333  }
334 
335  template <typename data2__>
337  {
338  if (this!=&d)
339  {
340  val[0]=d.real();
341  val[1]=d.nonreal();
342  }
343 
344  return *this;
345  }
346 
347  template <typename data2__>
349  {
350  val[0]=c.real();
351  return *this;
352  }
353 
354  template <typename data2__>
356  {
357  val[0]=c.real();
358  val[1]=c.nonreal();
359  return *this;
360  }
361 
362  // operator +=
364  {
365  val[0]+=d;
366  return *this;
367  }
369  {
370  val[0]+=d.real();
371  val[1]+=d.nonreal();
372  return *this;
373  }
374  template <typename data2__>
376  {
377  val[0]+=d.real();
378  val[1]+=d.nonreal();
379  return *this;
380  }
381  template <typename data2__>
383  {
384  val[0]+=c.real();
385  return *this;
386  }
387  template <typename data2__>
389  {
390  val[0]+=e.real();
391  val[1]+=e.nonreal();
392  return *this;
393  }
394 
395  // operator -=
397  {
398  val[0]-=d;
399  return *this;
400  }
402  {
403  val[0]-=d.real();
404  val[1]-=d.nonreal();
405  return *this;
406  }
407  template <typename data2__>
409  {
410  val[0]-=d.real();
411  val[1]-=d.nonreal();
412  return *this;
413  }
414  template <typename data2__>
416  {
417  val[0]-=c.real();
418  return *this;
419  }
420  template <typename data2__>
422  {
423  val[0]-=e.real();
424  val[1]-=e.nonreal();
425  return *this;
426  }
427 
428  // operator *=
430  {
431  val[0]*=d;
432  val[1]*=d;
433  return *this;
434  }
436  {
437  data_type val0(val[0]);
438 
439  val[0]=val0*d.real();
440  val[1]=val0*d.nonreal()+val[1]*d.real();
441  return *this;
442  }
443  template <typename data2__>
445  {
446  data_type val0(val[0]);
447 
448  val[0]=val0*d.real();
449  val[1]=val0*d.nonreal()+val[1]*d.real();
450  return *this;
451  }
452  template <typename data2__>
454  {
455  val[0]*=c.real();
456  val[1]*=c.real();
457  return *this;
458  }
459  template <typename data2__>
461  {
462  data_type val0(val[0]);
463 
464  val[0]=val0*e.real();
465  val[1]=val0*e.nonreal()+val[1]*e.real();
466  return *this;
467  }
468 
469  // operator /=
471  {
472  val[0]/=d;
473  val[1]/=d;
474  return *this;
475  }
477  {
478  data_type val0(val[0]);
479  data_type c(d.real());
480 
481  val[0]=val0/d.real();
482  val[1]=(val[1]*c-val0*d.nonreal())/c/c;
483  return *this;
484  }
485  template <typename data2__>
487  {
488  data_type val0(val[0]);
489  data2__ c(d.real());
490 
491  val[0]=val0/d.real();
492  val[1]=(val[1]*c-val0*d.nonreal())/c/c;
493  return *this;
494  }
495  template <typename data2__>
497  {
498  val[0]/=c.real();
499  val[1]/=c.real();
500  return *this;
501  }
502  template <typename data2__>
504  {
505  data_type val0(val[0]);
507 
508  val[0]=val0/e.real();
509  val[1]=(val[1]*c-val0*e.nonreal())/c/c;
510  return *this;
511  }
512 
513  bool exact(const data_type &d) const
514  {
515  return exact_equiv(d, 0);
516  }
518  {
519  return exact_equiv(d.real(), d.nonreal());
520  }
521  template <typename data2__>
523  {
524  return exact_equiv(d.real(), d.nonreal());
525  }
526  template <typename data2__>
528  {
529  return exact_equiv(c.real(), 0);
530  }
531  template <typename data2__>
533  {
534  return exact_equiv(e.real(), e.nonreal());
535  }
536 
537  bool nearly(const data_type &d, const data_type &eps) const
538  {
539  return nearly_equiv(d, 0, eps);
540  }
541  bool nearly(const dual<data_type, comp_real_only> &d, const data_type &eps) const
542  {
543  return nearly_equiv(d.real(), d.nonreal(), eps);
544  }
545  template <typename data2__>
546  bool nearly(const dual<data2__, comp_real_only> &d, const data_type &eps) const
547  {
548  return nearly_equiv(d.real(), d.nonreal(), eps);
549  }
550  template <typename data2__>
551  bool nearly(const dual_number::constant<data2__> &c, const data_type &eps) const
552  {
553  return nearly_equiv(c.real(), 0, eps);
554  }
555  template <typename data2__>
556  bool nearly(const dual_number::expression<data2__, comp_real_only> &e, const data_type &eps) const
557  {
558  return nearly_equiv(e.real(), e.nonreal(), eps);
559  }
560 
561  // operator ==
562  bool operator==(const data_type &d) const
563  {
564  if (comp_real_only)
565  return inexact_equiv(d);
566  else
567  return exact_equiv(d, 0);
568  }
570  {
571  if (comp_real_only)
572  return inexact_equiv(d.real());
573  else
574  return exact_equiv(d.real(), d.nonreal());
575  }
576  template <typename data2__>
578  {
579  if (comp_real_only)
580  return inexact_equiv(d.real());
581  else
582  return exact_equiv(d.real(), d.nonreal());
583  }
584  template <typename data2__>
586  {
587  return operator==(c.real());
588  }
589  template <typename data2__>
591  {
592  if (comp_real_only)
593  return inexact_equiv(e.real());
594  else
595  return exact_equiv(e.real(), e.nonreal());
596  }
597 
598  // operator !=
599  bool operator!=(const data_type &d) const
600  {
601  return !operator==(d);
602  }
604  {
605  return !operator==(d);
606  }
607  template <typename data2__>
609  {
610  return !operator==(d);
611  }
612  template <typename data2__>
614  {
615  return !operator==(c);
616  }
617  template <typename data2__>
619  {
620  return !operator==(e);
621  }
622 
623  // operator <=
624  bool operator<=(const data_type &d) const
625  {
626  if (comp_real_only)
627  return inexact_less_than_equal(d);
628  else
629  return exact_less_than_equal(d, 0);
630  }
631  bool operator<=(const dual<data_type, comp_real_only> &d) const
632  {
633  if (comp_real_only)
634  return inexact_less_than_equal(d.real());
635  else
636  return exact_less_than_equal(d.real(), d.nonreal());
637  }
638  template <typename data2__>
639  bool operator<=(const dual<data2__, comp_real_only> &d) const
640  {
641  if (comp_real_only)
642  return inexact_less_than_equal(d.real());
643  else
644  return exact_less_than_equal(d.real(), d.nonreal());
645  }
646  template <typename data2__>
647  bool operator<=(const dual_number::constant<data2__> &c) const
648  {
649  return operator<=(c.real());
650  }
651  template <typename data2__>
652  bool operator<=(const dual_number::expression<data2__, comp_real_only> &e) const
653  {
654  if (comp_real_only)
655  return inexact_less_than_equal(e.real());
656  else
657  return exact_less_than_equal(e.real(), e.nonreal());
658  }
659 
660  // operator <
661  bool operator<(const data_type &d) const
662  {
663  if (comp_real_only)
664  return inexact_less_than(d);
665  else
666  return exact_less_than(d, 0);
667  }
668  bool operator<(const dual<data_type, comp_real_only> &d) const
669  {
670  if (comp_real_only)
671  return inexact_less_than(d.real());
672  else
673  return exact_less_than(d.real(), d.nonreal());
674  }
675  template <typename data2__>
676  bool operator<(const dual<data2__, comp_real_only> &d) const
677  {
678  if (comp_real_only)
679  return inexact_less_than(d.real());
680  else
681  return exact_less_than(d.real(), d.nonreal());
682  }
683  template <typename data2__>
684  bool operator<(const dual_number::constant<data2__> &c) const
685  {
686  return operator<(c.real());
687  }
688  template <typename data2__>
689  bool operator<(const dual_number::expression<data2__, comp_real_only> &e) const
690  {
691  if (comp_real_only)
692  return inexact_less_than(e.real());
693  else
694  return exact_less_than(e.real(), e.nonreal());
695  }
696 
697  // operator >=
698  bool operator>=(const data_type &d) const
699  {
700  if (comp_real_only)
701  return inexact_greater_than_equal(d);
702  else
703  return exact_greater_than_equal(d, 0);
704  }
706  {
707  if (comp_real_only)
708  return inexact_greater_than_equal(d.real());
709  else
710  return exact_greater_than_equal(d.real(), d.nonreal());
711  }
712  template <typename data2__>
714  {
715  if (comp_real_only)
716  return inexact_greater_than_equal(d.real());
717  else
718  return exact_greater_than_equal(d.real(), d.nonreal());
719  }
720  template <typename data2__>
722  {
723  return operator>=(c.real());
724  }
725  template <typename data2__>
727  {
728  if (comp_real_only)
729  return inexact_greater_than_equal(e.real());
730  else
731  return exact_greater_than_equal(e.real(), e.nonreal());
732  }
733 
734  // operator >
735  bool operator>(const data_type &d) const
736  {
737  if (comp_real_only)
738  return inexact_greater_than(d);
739  else
740  return exact_greater_than(d, 0);
741  }
743  {
744  if (comp_real_only)
745  return inexact_greater_than(d.real());
746  else
747  return exact_greater_than(d.real(), d.nonreal());
748  }
749  template <typename data2__>
751  {
752  if (comp_real_only)
753  return inexact_greater_than(d.real());
754  else
755  return exact_greater_than(d.real(), d.nonreal());
756  }
757  template <typename data2__>
759  {
760  return operator>(c.real());
761  }
762  template <typename data2__>
764  {
765  if (comp_real_only)
766  return inexact_greater_than(e.real());
767  else
768  return exact_greater_than(e.real(), e.nonreal());
769  }
770 
771  void print(std::ostream &str) const
772  {
773  str << val[0] << " + " << val[1] << "ε";
774  }
775 
776  // TODO: Implement this
777  void input(std::istream &/*str*/)
778  {
779  assert(false);
780  }
781 
782  // TODO: Implement this
783  void write(std::ostream &/*str*/) const
784  {
785  assert(false);
786  }
787 
788  // TODO: Implement this
789  void read(std::istream &/*str*/)
790  {
791  assert(false);
792  }
793  };
794  }
795  }
796 }
797 
798 #ifdef _MSC_VER
799 # pragma warning(push)
800 # pragma warning(disable: 4244)
801 #endif
802 
803 // comparison operators
804 template <typename data2__, typename data__, bool comp_real_only>
806 {
807  return d==v;
808 }
809 template <typename data2__, typename data__, bool comp_real_only>
811 {
812  return d!=v;
813 }
814 template <typename data2__, typename data__, bool comp_real_only>
815 bool operator<=(const data2__ &v, const eli::mutil::ad::dual<data__, comp_real_only> &d)
816 {
817  return d>=v;
818 }
819 template <typename data2__, typename data__, bool comp_real_only>
820 bool operator<(const data2__ &v, const eli::mutil::ad::dual<data__, comp_real_only> &d)
821 {
822  return d>v;
823 }
824 template <typename data2__, typename data__, bool comp_real_only>
826 {
827  return d<=v;
828 }
829 template <typename data2__, typename data__, bool comp_real_only>
831 {
832  return d<v;
833 }
834 template <typename data2__, typename data__, bool comp_real_only>
836 {
837  return d==c;
838 }
839 template <typename data2__, typename data__, bool comp_real_only>
841 {
842  return d!=c;
843 }
844 template <typename data2__, typename data__, bool comp_real_only>
845 bool operator<=(const eli::mutil::ad::dual_number::constant<data2__> &c, const eli::mutil::ad::dual<data__, comp_real_only> &d)
846 {
847  return d>=c;
848 }
849 template <typename data2__, typename data__, bool comp_real_only>
850 bool operator<(const eli::mutil::ad::dual_number::constant<data2__> &c, const eli::mutil::ad::dual<data__, comp_real_only> &d)
851 {
852  return d>c;
853 }
854 template <typename data2__, typename data__, bool comp_real_only>
856 {
857  return d<=c;
858 }
859 template <typename data2__, typename data__, bool comp_real_only>
861 {
862  return d<c;
863 }
864 template <typename data2__, typename data__, bool comp_real_only>
866 {
867  return d==e;
868 }
869 template <typename data2__, typename data__, bool comp_real_only>
871 {
872  return d!=e;
873 }
874 template <typename data2__, typename data__, bool comp_real_only>
875 bool operator<=(const eli::mutil::ad::dual_number::expression<data2__, comp_real_only> &e, const eli::mutil::ad::dual<data__, comp_real_only> &d)
876 {
877  return d>=e;
878 }
879 template <typename data2__, typename data__, bool comp_real_only>
880 bool operator<(const eli::mutil::ad::dual_number::expression<data2__, comp_real_only> &e, const eli::mutil::ad::dual<data__, comp_real_only> &d)
881 {
882  return d>e;
883 }
884 template <typename data2__, typename data__, bool comp_real_only>
886 {
887  return d<=e;
888 }
889 template <typename data2__, typename data__, bool comp_real_only>
891 {
892  return d<e;
893 }
894 #ifdef _MSC_VER
895 # pragma warning(pop)
896 #endif
897 
898 // I/O functions
899 template <typename data__, bool comp_real_only>
900 std::ostream & operator<<(std::ostream &ostr, const eli::mutil::ad::dual<data__, comp_real_only> &d)
901 {
902  d.print(ostr);
903  return ostr;
904 }
905 
906 template <typename data__, bool comp_real_only>
907 std::ostream & operator<<(std::ostream &ostr, const eli::mutil::ad::dual_number::expression<data__, comp_real_only> &e)
908 {
910 
911  eli::mutil::ad::dual<data_type, comp_real_only> d(e.real(), e.nonreal());
912  d.print(ostr);
913  return ostr;
914 }
915 
916 template <typename data__, bool comp_real_only>
917 std::istream & operator>>(std::istream &istr, eli::mutil::ad::dual<data__, comp_real_only> &d)
918 {
919  d.input(istr);
920  return istr;
921 }
922 #endif
bool operator!=(const data_type &d) const
Definition: dual_number.hpp:599
dual< data_type, comp_real_only > & operator/=(const dual< data2__, comp_real_only > &d)
Definition: dual_number.hpp:486
dual< data_type, comp_real_only > & operator/=(const dual< data_type, comp_real_only > &d)
Definition: dual_number.hpp:476
dual< data_type, comp_real_only > & operator-=(const data_type &d)
Definition: dual_number.hpp:396
Definition: math.hpp:20
bool operator>=(const dual< data2__, comp_real_only > &d) const
Definition: dual_number.hpp:713
bool nearly(const dual_number::expression< data2__, comp_real_only > &e, const data_type &eps) const
Definition: dual_number.hpp:556
bool operator>=(const dual_number::expression< data2__, comp_real_only > &e) const
Definition: dual_number.hpp:726
bool nearly(const dual_number::constant< data2__ > &c, const data_type &eps) const
Definition: dual_number.hpp:551
void input(std::istream &)
Definition: dual_number.hpp:777
bool nearly_equiv(const data__ &r, const data__ &nr, const data__ &eps) const
Definition: dual_number.hpp:206
bool exact(const dual< data2__, comp_real_only > &d) const
Definition: dual_number.hpp:522
dual(const dual< data_type, comp_real_only > &d)
Definition: dual_number.hpp:290
dual< data_type, comp_real_only > & operator=(const dual< data2__, comp_real_only > &d)
Definition: dual_number.hpp:336
bool operator==(const dual< data_type, comp_real_only > &d) const
Definition: dual_number.hpp:569
bool exact_less_than(const data__ &, const data__ &) const
Definition: dual_number.hpp:216
bool operator==(const data_type &v) const
Definition: dual_number.hpp:69
dual< data_type, comp_real_only > & operator=(const dual< data_type, comp_real_only > &d)
Definition: dual_number.hpp:324
dual< data_type, comp_real_only > & operator*=(const dual_number::expression< data2__, comp_real_only > &e)
Definition: dual_number.hpp:460
expression(const T__ &e)
Definition: dual_number.hpp:63
dual(const data__ &v)
Definition: dual_number.hpp:278
data__ data_type
Definition: dual_number.hpp:192
~dual()
Definition: dual_number.hpp:310
Definition: dual_number.hpp:55
dual< data_type, comp_real_only > & operator*=(const data_type &d)
Definition: dual_number.hpp:429
bool operator>(const expression< T__, comp_real_only > &e) const
Definition: dual_number.hpp:132
T__::data_type data_type
Definition: dual_number.hpp:61
void set_nonreal(const data_type &nr)
Definition: dual_number.hpp:315
void read(std::istream &)
Definition: dual_number.hpp:789
bool operator!=(const data_type &v) const
Definition: dual_number.hpp:81
const data_type & val
Definition: dual_number.hpp:42
dual< data_type, comp_real_only > & operator=(const data_type &v)
Definition: dual_number.hpp:317
dual< data_type, comp_real_only > & operator-=(const dual_number::expression< data2__, comp_real_only > &e)
Definition: dual_number.hpp:421
bool operator>=(const dual< data_type, comp_real_only > &d) const
Definition: dual_number.hpp:705
dual< data_type, comp_real_only > & operator-=(const dual< data2__, comp_real_only > &d)
Definition: dual_number.hpp:408
data_type nonreal() const
Definition: dual_number.hpp:313
bool exact_greater_than(const data__ &, const data__ &) const
Definition: dual_number.hpp:230
bool exact(const dual_number::constant< data2__ > &c) const
Definition: dual_number.hpp:527
dual< data_type, comp_real_only > & operator-=(const dual< data_type, comp_real_only > &d)
Definition: dual_number.hpp:401
dual()
Definition: dual_number.hpp:270
dual< data_type, comp_real_only > & operator+=(const data_type &d)
Definition: dual_number.hpp:363
bool inexact_less_than_equal(const data__ &r) const
Definition: dual_number.hpp:254
bool operator==(const data2__ &v, const eli::mutil::ad::dual_number::expression< data__, comp_real_only > &e)
Definition: dual_number.hpp:149
Definition: dual_number.hpp:36
data_type real() const
Definition: dual_number.hpp:312
bool exact_equiv(const data__ &r, const data__ &nr) const
Definition: dual_number.hpp:198
dual< data_type, comp_real_only > & operator+=(const dual_number::constant< data2__ > &c)
Definition: dual_number.hpp:382
bool operator==(const dual_number::expression< data2__, comp_real_only > &e) const
Definition: dual_number.hpp:590
data__ val[2]
Definition: dual_number.hpp:195
bool operator>(const data2__ &v, const eli::mutil::ad::dual_number::expression< data__, comp_real_only > &e)
Definition: dual_number.hpp:174
bool operator!=(const data2__ &v, const eli::mutil::ad::dual_number::expression< data__, comp_real_only > &e)
Definition: dual_number.hpp:154
bool operator>(const dual< data_type, comp_real_only > &d) const
Definition: dual_number.hpp:742
constant(const data_type &v)
Definition: dual_number.hpp:45
dual< data_type, comp_real_only > & operator*=(const dual_number::constant< data2__ > &c)
Definition: dual_number.hpp:453
bool operator>(const data_type &v) const
Definition: dual_number.hpp:127
bool inexact_greater_than_equal(const data__ &r) const
Definition: dual_number.hpp:264
dual< data_type, comp_real_only > & operator/=(const dual_number::constant< data2__ > &c)
Definition: dual_number.hpp:496
dual< data_type, comp_real_only > & operator/=(const data_type &d)
Definition: dual_number.hpp:470
dual< data_type, comp_real_only > & operator*=(const dual< data_type, comp_real_only > &d)
Definition: dual_number.hpp:435
dual(const dual_number::expression< data2__, comp_real_only > &c)
Definition: dual_number.hpp:304
bool exact(const data_type &d) const
Definition: dual_number.hpp:513
bool operator<=(const data_type &v) const
Definition: dual_number.hpp:91
void print(std::ostream &str) const
Definition: dual_number.hpp:771
bool nearly(const data_type &d, const data_type &eps) const
Definition: dual_number.hpp:537
bool inexact_equiv(const data__ &r) const
Definition: dual_number.hpp:244
void set_real(const data_type &r)
Definition: dual_number.hpp:314
bool operator!=(const expression< T__, comp_real_only > &e) const
Definition: dual_number.hpp:85
bool operator>(const dual_number::expression< data2__, comp_real_only > &e) const
Definition: dual_number.hpp:763
bool operator>=(const data_type &v) const
Definition: dual_number.hpp:115
bool inexact_less_than(const data__ &r) const
Definition: dual_number.hpp:249
dual< data_type, comp_real_only > & operator+=(const dual_number::expression< data2__, comp_real_only > &e)
Definition: dual_number.hpp:388
bool operator>(const data_type &d) const
Definition: dual_number.hpp:735
bool operator<(const data_type &d) const
Definition: dual_number.hpp:661
bool operator!=(const dual< data2__, comp_real_only > &d) const
Definition: dual_number.hpp:608
bool operator>=(const dual_number::constant< data2__ > &c) const
Definition: dual_number.hpp:721
bool exact_greater_than_equal(const data__ &, const data__ &) const
Definition: dual_number.hpp:237
dual< data_type, comp_real_only > & operator+=(const dual< data_type, comp_real_only > &d)
Definition: dual_number.hpp:368
dual< data_type, comp_real_only > & operator=(const dual_number::constant< data2__ > &c)
Definition: dual_number.hpp:348
Definition: dual_number.hpp:28
std::istream & operator>>(std::istream &istr, eli::mutil::ad::dual< data__, comp_real_only > &d)
Definition: dual_number.hpp:917
const T__ expr
Definition: dual_number.hpp:58
dual(const data_type &v1, const data_type &v2)
Definition: dual_number.hpp:284
dual< data_type, comp_real_only > & operator+=(const dual< data2__, comp_real_only > &d)
Definition: dual_number.hpp:375
bool operator==(const data_type &d) const
Definition: dual_number.hpp:562
bool operator!=(const dual_number::constant< data2__ > &c) const
Definition: dual_number.hpp:613
bool operator==(const dual_number::constant< data2__ > &c) const
Definition: dual_number.hpp:585
bool nearly(const dual< data2__, comp_real_only > &d, const data_type &eps) const
Definition: dual_number.hpp:546
dual< data_type, comp_real_only > & operator-=(const dual_number::constant< data2__ > &c)
Definition: dual_number.hpp:415
dual(const dual_number::constant< data2__ > &c)
Definition: dual_number.hpp:297
bool operator>=(const expression< T__, comp_real_only > &e) const
Definition: dual_number.hpp:120
bool nearly(const dual< data_type, comp_real_only > &d, const data_type &eps) const
Definition: dual_number.hpp:541
void write(std::ostream &) const
Definition: dual_number.hpp:783
bool operator>=(const data2__ &v, const eli::mutil::ad::dual_number::expression< data__, comp_real_only > &e)
Definition: dual_number.hpp:169
bool inexact_greater_than(const data__ &r) const
Definition: dual_number.hpp:259
bool exact(const dual< data_type, comp_real_only > &d) const
Definition: dual_number.hpp:517
dual< data_type, comp_real_only > & operator=(const dual_number::expression< data2__, comp_real_only > &c)
Definition: dual_number.hpp:355
const data_type nonreal() const
Definition: dual_number.hpp:66
bool operator!=(const dual< data_type, comp_real_only > &d) const
Definition: dual_number.hpp:603
data_type nonreal() const
Definition: dual_number.hpp:48
bool exact(const dual_number::expression< data2__, comp_real_only > &e) const
Definition: dual_number.hpp:532
bool exact_less_than_equal(const data__ &, const data__ &) const
Definition: dual_number.hpp:223
data_type real() const
Definition: dual_number.hpp:47
bool operator>=(const data_type &d) const
Definition: dual_number.hpp:698
dual< data_type, comp_real_only > & operator*=(const dual< data2__, comp_real_only > &d)
Definition: dual_number.hpp:444
bool operator<(const data_type &v) const
Definition: dual_number.hpp:103
dual< data_type, comp_real_only > & operator/=(const dual_number::expression< data2__, comp_real_only > &e)
Definition: dual_number.hpp:503
const data_type real() const
Definition: dual_number.hpp:65
bool operator!=(const dual_number::expression< data2__, comp_real_only > &e) const
Definition: dual_number.hpp:618
data__ data_type
Definition: dual_number.hpp:39
bool operator>(const dual_number::constant< data2__ > &c) const
Definition: dual_number.hpp:758
bool operator==(const expression< T__, comp_real_only > &e) const
Definition: dual_number.hpp:74
bool operator==(const dual< data2__, comp_real_only > &d) const
Definition: dual_number.hpp:577
bool operator<=(const data_type &d) const
Definition: dual_number.hpp:624
bool operator>(const dual< data2__, comp_real_only > &d) const
Definition: dual_number.hpp:750