Attachment #75347 for bug #108855

View | Details | Raw Unified | Return to bug 108855
Collapse All | Expand All

Lines 8-14 Link Here

(-)ports/math/libgmp4.new/Makefile (-1 / +1 lines)
8		8
9	PORTNAME= libgmp	9	PORTNAME= libgmp
10	PORTVERSION= 4.2.1	10	PORTVERSION= 4.2.1
11	PORTREVISION= 1	11	PORTREVISION= 2
12	CATEGORIES= math devel	12	CATEGORIES= math devel
13	MASTER_SITES= ${MASTER_SITE_GNU}	13	MASTER_SITES= ${MASTER_SITE_GNU}
14	MASTER_SITE_SUBDIR= gmp	14	MASTER_SITE_SUBDIR= gmp




[2006-11-30] With the C++ wrapper, ternary operations such as a=c+b*a where the desination variable is also used as a source, will compute garbage.
http://www.swox.com/gmp/patches/gmpxx.h.ternary.diff

Index: gmpxx.h
===================================================================
RCS file: /home/cvsfiles/gmp42/gmpxx.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -p -2 -r1.4 -r1.5
*** gmpxx.h	8 Apr 2006 19:58:48 -0000	1.4
--- gmpxx.h	31 Oct 2006 10:40:59 -0000	1.5
*************** struct __gmp_cmp_function
*** 1278,1367 ****
  };
  
- struct __gmp_ternary_addmul // z = w + v * u
- {
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
-   { mpz_set(z, w); mpz_addmul(z, v, u); }
- 
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
-   { mpz_set(z, w); mpz_addmul_ui(z, v, l); }
-   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
-   { mpz_set(z, w); mpz_addmul_ui(z, v, l); }
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
-   {
-     mpz_set(z, w);
-     if (l >= 0)
-       mpz_addmul_ui(z, v, l);
-     else
-       mpz_submul_ui(z, v, -l);
-   }
-   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
-   {
-     mpz_set(z, w);
-     if (l >= 0)
-       mpz_addmul_ui(z, v, l);
-     else
-       mpz_submul_ui(z, v, -l);
-   }
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
-   {
-     mpz_t temp;
-     mpz_init_set_d(temp, d);
-     mpz_set(z, w);
-     mpz_addmul(z, v, temp);
-     mpz_clear(temp);
-   }
-   static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
-   {
-     mpz_t temp;
-     mpz_init_set_d(temp, d);
-     mpz_set(z, w);
-     mpz_addmul(z, temp, v);
-     mpz_clear(temp);
-   }
- };
- 
- struct __gmp_ternary_submul // z = w - v * u
- {
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
-   { mpz_set(z, w); mpz_submul(z, v, u); }
- 
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
-   { mpz_set(z, w); mpz_submul_ui(z, v, l); }
-   static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
-   { mpz_set(z, w); mpz_submul_ui(z, v, l); }
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
-   {
-     mpz_set(z, w);
-     if (l >= 0)
-       mpz_submul_ui(z, v, l);
-     else
-       mpz_addmul_ui(z, v, -l);
-   }
-   static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
-   {
-     mpz_set(z, w);
-     if (l >= 0)
-       mpz_submul_ui(z, v, l);
-     else
-       mpz_addmul_ui(z, v, -l);
-   }
-   static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
-   {
-     mpz_t temp;
-     mpz_init_set_d(temp, d);
-     mpz_set(z, w);
-     mpz_submul(z, v, temp);
-     mpz_clear(temp);
-   }
-   static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
-   {
-     mpz_t temp;
-     mpz_init_set_d(temp, d);
-     mpz_set(z, w);
-     mpz_submul(z, temp, v);
-     mpz_clear(temp);
-   }
- };
- 
  struct __gmp_rand_function
  {
--- 1278,1281 ----
*************** __GMPZQ_DEFINE_EXPR(__gmp_binary_minus)
*** 2863,3277 ****
  
  
- /* Integer ternary expressions of the kind `a+b*c' or `a*b+c' can be
-    evaluated directly via mpz_addmul */
- 
- // a + b * c
- #define __GMP_DEFINE_TERNARY_EXPR(eval_fun1, eval_fun2, eval_both)          \
-                                                                             \
- template <>                                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> >, eval_fun2> >  \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr                                                        \
-     <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> > val2_type; \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   { eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(),          \
-        expr.val2.get_val2().get_mpz_t()); }                                 \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T>                                                          \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<mpz_class, T, eval_fun1> >, eval_fun2> >          \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr                                                        \
-     <mpz_t, __gmp_binary_expr<mpz_class, T, eval_fun1> > val2_type;         \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   { eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(),          \
-        expr.val2.get_val2()); }                                             \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T>                                                          \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<T, mpz_class, eval_fun1> >, eval_fun2> >          \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr                                                        \
-     <mpz_t, __gmp_binary_expr<T, mpz_class, eval_fun1> > val2_type;         \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   { eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), expr.val2.get_val1(),                      \
-        expr.val2.get_val2().get_mpz_t()); }                                 \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T>                                                          \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpz_t, T>, eval_fun1> >,    \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <mpz_class, __gmp_expr<mpz_t, T>, eval_fun1> > val2_type;               \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val2.get_val2());                                   \
-     eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(),          \
-        temp.get_mpz_t());                                                   \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T>                                                          \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, mpz_class, eval_fun1> >,    \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <__gmp_expr<mpz_t, T>, mpz_class, eval_fun1> > val2_type;               \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val2.get_val1());                                   \
-     eval_both::eval(z, expr.val1.get_mpz_t(), temp.get_mpz_t(),             \
- 		    expr.val2.get_val2().get_mpz_t());                      \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, U, eval_fun1> >,            \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <__gmp_expr<mpz_t, T>, U, eval_fun1> > val2_type;                       \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val2.get_val1());                                   \
-     eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), temp.get_mpz_t(), expr.val2.get_val2());   \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<T, __gmp_expr<mpz_t, U>, eval_fun1> >,            \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <T, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type;                       \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val2.get_val2());                                   \
-     eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), expr.val2.get_val1(), temp.get_mpz_t());   \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr             \
- <mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, __gmp_expr<mpz_t, U>,       \
-   eval_fun1> >, eval_fun2> >                                                \
- {                                                                           \
- private:                                                                    \
-   typedef mpz_class val1_type;                                              \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <__gmp_expr<mpz_t, T>, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type;    \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp1(expr.val2.get_val1());                                  \
-     mpz_class temp2(expr.val2.get_val2());                                  \
-     eval_both::eval                                                         \
-       (z, expr.val1.get_mpz_t(), temp1.get_mpz_t(), temp2.get_mpz_t());     \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T>                                                          \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> >,   \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr                                                        \
-     <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> > val2_type; \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val1);                                              \
-     eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1().get_mpz_t(),  \
- 		    expr.val2.get_val2().get_mpz_t());                      \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, U, eval_fun1> >,           \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr                                                        \
-     <mpz_t, __gmp_binary_expr<mpz_class, U, eval_fun1> > val2_type;         \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val1);                                              \
-     eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1().get_mpz_t(),  \
- 		    expr.val2.get_val2());                                  \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<U, mpz_class, eval_fun1> >,           \
-   eval_fun2> >                                                              \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr                                                        \
-     <mpz_t, __gmp_binary_expr<U, mpz_class, eval_fun1> > val2_type;         \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp(expr.val1);                                              \
-     eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1(),              \
- 		    expr.val2.get_val2().get_mpz_t());                      \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpz_t, U>,      \
-   eval_fun1> >, eval_fun2> >                                                \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <mpz_class, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type;               \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp1(expr.val1);                                             \
-     mpz_class temp2(expr.val2.get_val2());                                  \
-     eval_both::eval                                                         \
-       (z, temp1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(),              \
-        temp2.get_mpz_t());                                                  \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U>                                                 \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, mpz_class,      \
-   eval_fun1> >, eval_fun2> >                                                \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <__gmp_expr<mpz_t, U>, mpz_class, eval_fun1> > val2_type;               \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp1(expr.val1);                                             \
-     mpz_class temp2(expr.val2.get_val1());                                  \
-     eval_both::eval(z, temp1.get_mpz_t(), temp2.get_mpz_t(),                \
- 		    expr.val2.get_val2().get_mpz_t());                      \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U, class V>                                        \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, V,              \
-   eval_fun1> >, eval_fun2> >                                                \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-   <__gmp_expr<mpz_t, U>, V, eval_fun1> > val2_type;                         \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp1(expr.val1);                                             \
-     mpz_class temp2(expr.val2.get_val1());                                  \
-     eval_both::eval                                                         \
-       (z, temp1.get_mpz_t(), temp2.get_mpz_t(), expr.val2.get_val2());      \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U, class V>                                        \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<U, __gmp_expr<mpz_t, V>,              \
-   eval_fun1> >, eval_fun2> >                                                \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-     <U, __gmp_expr<mpz_t, V>, eval_fun1> > val2_type;                       \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp1(expr.val1);                                             \
-     mpz_class temp2(expr.val2.get_val2());                                  \
-     eval_both::eval                                                         \
-       (z, temp1.get_mpz_t(), expr.val2.get_val1(), temp2.get_mpz_t());      \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };                                                                          \
-                                                                             \
- template <class T, class U, class V>                                        \
- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>,             \
-   __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>,                 \
-   __gmp_expr<mpz_t, V>, eval_fun1> >, eval_fun2> >                          \
- {                                                                           \
- private:                                                                    \
-   typedef __gmp_expr<mpz_t, T> val1_type;                                   \
-   typedef __gmp_expr<mpz_t, __gmp_binary_expr                               \
-   <__gmp_expr<mpz_t, U>, __gmp_expr<mpz_t, V>, eval_fun1> > val2_type;      \
-                                                                             \
-   __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr;                  \
- public:                                                                     \
-   __gmp_expr(const val1_type &val1, const val2_type &val2)                  \
-     : expr(val1, val2) { }                                                  \
-   void eval(mpz_ptr z) const                                                \
-   {                                                                         \
-     mpz_class temp1(expr.val1);                                             \
-     mpz_class temp2(expr.val2.get_val1());                                  \
-     mpz_class temp3(expr.val2.get_val2());                                  \
-     eval_both::eval                                                         \
-       (z, temp1.get_mpz_t(), temp2.get_mpz_t(), temp3.get_mpz_t());         \
-   }                                                                         \
-   const val1_type & get_val1() const { return expr.val1; }                  \
-   const val2_type & get_val2() const { return expr.val2; }                  \
-   unsigned long int get_prec() const { return mpf_get_default_prec(); }     \
- };
- 
- 
- __GMP_DEFINE_TERNARY_EXPR(__gmp_binary_multiplies, __gmp_binary_plus,
- 			  __gmp_ternary_addmul)
- __GMP_DEFINE_TERNARY_EXPR(__gmp_binary_multiplies, __gmp_binary_minus,
- 			  __gmp_ternary_submul)
  
  /**************** Macros for defining functions ****************/
--- 2777,2780 ----




[2006-09-23] In mpz_set_d, arguments smaller than 1e-19 will trigger undefined behaviour, typically a crash. Note that this is a somewhat deegnerate use of mpz_set_d that should not normally happen, since any arguments < 1 will yield 0.
http://www.swox.com/gmp/patches/mpz_set_d.diff

*** mpz/set_d.c	14 Mar 2006 15:57:54 -0000	1.1
--- mpz/set_d.c	31 May 2006 14:50:05 -0000	1.2
*************** mpz_set_d (mpz_ptr r, double d)
*** 57,60 ****
--- 58,64 ----
      _mpz_realloc (r, rn);
  
+   if (rn <= 0)
+     rn = 0;
+ 
    rp = PTR (r);


Return to bug 108855

Line 0 Link Here

(-)ports/math/libgmp4.new/files/patch-gmpxx.h.ternary (+522 lines)
		1	[2006-11-30] With the C++ wrapper, ternary operations such as a=c+b*a where the desination variable is also used as a source, will compute garbage.
		2	http://www.swox.com/gmp/patches/gmpxx.h.ternary.diff
		3
		4	Index: gmpxx.h
		5	===================================================================
		6	RCS file: /home/cvsfiles/gmp42/gmpxx.h,v
		7	retrieving revision 1.4
		8	retrieving revision 1.5
		9	diff -p -2 -r1.4 -r1.5
		10	*** gmpxx.h 8 Apr 2006 19:58:48 -0000 1.4
		11	--- gmpxx.h 31 Oct 2006 10:40:59 -0000 1.5
		12	*************** struct __gmp_cmp_function
		13	* 1278,1367 **
		14	};
		15
		16	- struct __gmp_ternary_addmul // z = w + v * u
		17	- {
		18	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
		19	- { mpz_set(z, w); mpz_addmul(z, v, u); }
		20	-
		21	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
		22	- { mpz_set(z, w); mpz_addmul_ui(z, v, l); }
		23	- static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
		24	- { mpz_set(z, w); mpz_addmul_ui(z, v, l); }
		25	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
		26	- {
		27	- mpz_set(z, w);
		28	- if (l >= 0)
		29	- mpz_addmul_ui(z, v, l);
		30	- else
		31	- mpz_submul_ui(z, v, -l);
		32	- }
		33	- static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
		34	- {
		35	- mpz_set(z, w);
		36	- if (l >= 0)
		37	- mpz_addmul_ui(z, v, l);
		38	- else
		39	- mpz_submul_ui(z, v, -l);
		40	- }
		41	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
		42	- {
		43	- mpz_t temp;
		44	- mpz_init_set_d(temp, d);
		45	- mpz_set(z, w);
		46	- mpz_addmul(z, v, temp);
		47	- mpz_clear(temp);
		48	- }
		49	- static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
		50	- {
		51	- mpz_t temp;
		52	- mpz_init_set_d(temp, d);
		53	- mpz_set(z, w);
		54	- mpz_addmul(z, temp, v);
		55	- mpz_clear(temp);
		56	- }
		57	- };
		58	-
		59	- struct __gmp_ternary_submul // z = w - v * u
		60	- {
		61	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
		62	- { mpz_set(z, w); mpz_submul(z, v, u); }
		63	-
		64	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
65	- { mpz_set(z, w); mpz_submul_ui(z, v, l); }
66	- static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
67	- { mpz_set(z, w); mpz_submul_ui(z, v, l); }
68	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
69	- {
70	- mpz_set(z, w);
71	- if (l >= 0)
72	- mpz_submul_ui(z, v, l);
73	- else
74	- mpz_addmul_ui(z, v, -l);
75	- }
76	- static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
77	- {
78	- mpz_set(z, w);
79	- if (l >= 0)
80	- mpz_submul_ui(z, v, l);
81	- else
82	- mpz_addmul_ui(z, v, -l);
83	- }
84	- static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
85	- {
86	- mpz_t temp;
87	- mpz_init_set_d(temp, d);
88	- mpz_set(z, w);
89	- mpz_submul(z, v, temp);
90	- mpz_clear(temp);
91	- }
92	- static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
93	- {
94	- mpz_t temp;
95	- mpz_init_set_d(temp, d);
96	- mpz_set(z, w);
97	- mpz_submul(z, temp, v);
98	- mpz_clear(temp);
99	- }
100	- };
101	-
102	struct __gmp_rand_function
103	{
104	--- 1278,1281 ----
105	*************** __GMPZQ_DEFINE_EXPR(__gmp_binary_minus)
106	* 2863,3277 **
107
108
109	- /* Integer ternary expressions of the kind `a+bc' or `ab+c' can be
110	- evaluated directly via mpz_addmul */
111	-
112	- // a + b * c
113	- #define __GMP_DEFINE_TERNARY_EXPR(eval_fun1, eval_fun2, eval_both) \
114	- \
115	- template <> \
116	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
117	- <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> >, eval_fun2> > \
118	- { \
119	- private: \
120	- typedef mpz_class val1_type; \
121	- typedef __gmp_expr \
122	- <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> > val2_type; \
123	- \
124	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
125	- public: \
126	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
127	- : expr(val1, val2) { } \
128	- void eval(mpz_ptr z) const \
129	- { eval_both::eval \
130	- (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
131	- expr.val2.get_val2().get_mpz_t()); } \
132	- const val1_type & get_val1() const { return expr.val1; } \
133	- const val2_type & get_val2() const { return expr.val2; } \
134	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
135	- }; \
136	- \
137	- template <class T> \
138	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
139	- <mpz_t, __gmp_binary_expr<mpz_class, T, eval_fun1> >, eval_fun2> > \
140	- { \
141	- private: \
142	- typedef mpz_class val1_type; \
143	- typedef __gmp_expr \
144	- <mpz_t, __gmp_binary_expr<mpz_class, T, eval_fun1> > val2_type; \
145	- \
146	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
147	- public: \
148	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
149	- : expr(val1, val2) { } \
150	- void eval(mpz_ptr z) const \
151	- { eval_both::eval \
152	- (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
153	- expr.val2.get_val2()); } \
154	- const val1_type & get_val1() const { return expr.val1; } \
155	- const val2_type & get_val2() const { return expr.val2; } \
156	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
157	- }; \
158	- \
159	- template <class T> \
160	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
161	- <mpz_t, __gmp_binary_expr<T, mpz_class, eval_fun1> >, eval_fun2> > \
162	- { \
163	- private: \
164	- typedef mpz_class val1_type; \
165	- typedef __gmp_expr \
166	- <mpz_t, __gmp_binary_expr<T, mpz_class, eval_fun1> > val2_type; \
167	- \
168	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
169	- public: \
170	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
171	- : expr(val1, val2) { } \
172	- void eval(mpz_ptr z) const \
173	- { eval_both::eval \
174	- (z, expr.val1.get_mpz_t(), expr.val2.get_val1(), \
175	- expr.val2.get_val2().get_mpz_t()); } \
176	- const val1_type & get_val1() const { return expr.val1; } \
177	- const val2_type & get_val2() const { return expr.val2; } \
178	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
179	- }; \
180	- \
181	- template <class T> \
182	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
183	- <mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpz_t, T>, eval_fun1> >, \
184	- eval_fun2> > \
185	- { \
186	- private: \
187	- typedef mpz_class val1_type; \
188	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
189	- <mpz_class, __gmp_expr<mpz_t, T>, eval_fun1> > val2_type; \
190	- \
191	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
192	- public: \
193	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
194	- : expr(val1, val2) { } \
195	- void eval(mpz_ptr z) const \
196	- { \
197	- mpz_class temp(expr.val2.get_val2()); \
198	- eval_both::eval \
199	- (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
200	- temp.get_mpz_t()); \
201	- } \
202	- const val1_type & get_val1() const { return expr.val1; } \
203	- const val2_type & get_val2() const { return expr.val2; } \
204	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
205	- }; \
206	- \
207	- template <class T> \
208	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
209	- <mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, mpz_class, eval_fun1> >, \
210	- eval_fun2> > \
211	- { \
212	- private: \
213	- typedef mpz_class val1_type; \
214	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
215	- <__gmp_expr<mpz_t, T>, mpz_class, eval_fun1> > val2_type; \
216	- \
217	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
218	- public: \
219	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
220	- : expr(val1, val2) { } \
221	- void eval(mpz_ptr z) const \
222	- { \
223	- mpz_class temp(expr.val2.get_val1()); \
224	- eval_both::eval(z, expr.val1.get_mpz_t(), temp.get_mpz_t(), \
225	- expr.val2.get_val2().get_mpz_t()); \
226	- } \
227	- const val1_type & get_val1() const { return expr.val1; } \
228	- const val2_type & get_val2() const { return expr.val2; } \
229	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
230	- }; \
231	- \
232	- template <class T, class U> \
233	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
234	- <mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, U, eval_fun1> >, \
235	- eval_fun2> > \
236	- { \
237	- private: \
238	- typedef mpz_class val1_type; \
239	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
240	- <__gmp_expr<mpz_t, T>, U, eval_fun1> > val2_type; \
241	- \
242	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
243	- public: \
244	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
245	- : expr(val1, val2) { } \
246	- void eval(mpz_ptr z) const \
247	- { \
248	- mpz_class temp(expr.val2.get_val1()); \
249	- eval_both::eval \
250	- (z, expr.val1.get_mpz_t(), temp.get_mpz_t(), expr.val2.get_val2()); \
251	- } \
252	- const val1_type & get_val1() const { return expr.val1; } \
253	- const val2_type & get_val2() const { return expr.val2; } \
254	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
255	- }; \
256	- \
257	- template <class T, class U> \
258	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
259	- <mpz_t, __gmp_binary_expr<T, __gmp_expr<mpz_t, U>, eval_fun1> >, \
260	- eval_fun2> > \
261	- { \
262	- private: \
263	- typedef mpz_class val1_type; \
264	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
265	- <T, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type; \
266	- \
267	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
268	- public: \
269	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
270	- : expr(val1, val2) { } \
271	- void eval(mpz_ptr z) const \
272	- { \
273	- mpz_class temp(expr.val2.get_val2()); \
274	- eval_both::eval \
275	- (z, expr.val1.get_mpz_t(), expr.val2.get_val1(), temp.get_mpz_t()); \
276	- } \
277	- const val1_type & get_val1() const { return expr.val1; } \
278	- const val2_type & get_val2() const { return expr.val2; } \
279	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
280	- }; \
281	- \
282	- template <class T, class U> \
283	- class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
284	- <mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, __gmp_expr<mpz_t, U>, \
285	- eval_fun1> >, eval_fun2> > \
286	- { \
287	- private: \
288	- typedef mpz_class val1_type; \
289	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
290	- <__gmp_expr<mpz_t, T>, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type; \
291	- \
292	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
293	- public: \
294	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
295	- : expr(val1, val2) { } \
296	- void eval(mpz_ptr z) const \
297	- { \
298	- mpz_class temp1(expr.val2.get_val1()); \
299	- mpz_class temp2(expr.val2.get_val2()); \
300	- eval_both::eval \
301	- (z, expr.val1.get_mpz_t(), temp1.get_mpz_t(), temp2.get_mpz_t()); \
302	- } \
303	- const val1_type & get_val1() const { return expr.val1; } \
304	- const val2_type & get_val2() const { return expr.val2; } \
305	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
306	- }; \
307	- \
308	- template <class T> \
309	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
310	- __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> >, \
311	- eval_fun2> > \
312	- { \
313	- private: \
314	- typedef __gmp_expr<mpz_t, T> val1_type; \
315	- typedef __gmp_expr \
316	- <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> > val2_type; \
317	- \
318	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
319	- public: \
320	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
321	- : expr(val1, val2) { } \
322	- void eval(mpz_ptr z) const \
323	- { \
324	- mpz_class temp(expr.val1); \
325	- eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
326	- expr.val2.get_val2().get_mpz_t()); \
327	- } \
328	- const val1_type & get_val1() const { return expr.val1; } \
329	- const val2_type & get_val2() const { return expr.val2; } \
330	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
331	- }; \
332	- \
333	- template <class T, class U> \
334	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
335	- __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, U, eval_fun1> >, \
336	- eval_fun2> > \
337	- { \
338	- private: \
339	- typedef __gmp_expr<mpz_t, T> val1_type; \
340	- typedef __gmp_expr \
341	- <mpz_t, __gmp_binary_expr<mpz_class, U, eval_fun1> > val2_type; \
342	- \
343	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
344	- public: \
345	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
346	- : expr(val1, val2) { } \
347	- void eval(mpz_ptr z) const \
348	- { \
349	- mpz_class temp(expr.val1); \
350	- eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
351	- expr.val2.get_val2()); \
352	- } \
353	- const val1_type & get_val1() const { return expr.val1; } \
354	- const val2_type & get_val2() const { return expr.val2; } \
355	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
356	- }; \
357	- \
358	- template <class T, class U> \
359	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
360	- __gmp_expr<mpz_t, __gmp_binary_expr<U, mpz_class, eval_fun1> >, \
361	- eval_fun2> > \
362	- { \
363	- private: \
364	- typedef __gmp_expr<mpz_t, T> val1_type; \
365	- typedef __gmp_expr \
366	- <mpz_t, __gmp_binary_expr<U, mpz_class, eval_fun1> > val2_type; \
367	- \
368	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
369	- public: \
370	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
371	- : expr(val1, val2) { } \
372	- void eval(mpz_ptr z) const \
373	- { \
374	- mpz_class temp(expr.val1); \
375	- eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1(), \
376	- expr.val2.get_val2().get_mpz_t()); \
377	- } \
378	- const val1_type & get_val1() const { return expr.val1; } \
379	- const val2_type & get_val2() const { return expr.val2; } \
380	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
381	- }; \
382	- \
383	- template <class T, class U> \
384	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
385	- __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpz_t, U>, \
386	- eval_fun1> >, eval_fun2> > \
387	- { \
388	- private: \
389	- typedef __gmp_expr<mpz_t, T> val1_type; \
390	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
391	- <mpz_class, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type; \
392	- \
393	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
394	- public: \
395	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
396	- : expr(val1, val2) { } \
397	- void eval(mpz_ptr z) const \
398	- { \
399	- mpz_class temp1(expr.val1); \
400	- mpz_class temp2(expr.val2.get_val2()); \
401	- eval_both::eval \
402	- (z, temp1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
403	- temp2.get_mpz_t()); \
404	- } \
405	- const val1_type & get_val1() const { return expr.val1; } \
406	- const val2_type & get_val2() const { return expr.val2; } \
407	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
408	- }; \
409	- \
410	- template <class T, class U> \
411	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
412	- __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, mpz_class, \
413	- eval_fun1> >, eval_fun2> > \
414	- { \
415	- private: \
416	- typedef __gmp_expr<mpz_t, T> val1_type; \
417	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
418	- <__gmp_expr<mpz_t, U>, mpz_class, eval_fun1> > val2_type; \
419	- \
420	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
421	- public: \
422	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
423	- : expr(val1, val2) { } \
424	- void eval(mpz_ptr z) const \
425	- { \
426	- mpz_class temp1(expr.val1); \
427	- mpz_class temp2(expr.val2.get_val1()); \
428	- eval_both::eval(z, temp1.get_mpz_t(), temp2.get_mpz_t(), \
429	- expr.val2.get_val2().get_mpz_t()); \
430	- } \
431	- const val1_type & get_val1() const { return expr.val1; } \
432	- const val2_type & get_val2() const { return expr.val2; } \
433	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
434	- }; \
435	- \
436	- template <class T, class U, class V> \
437	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
438	- __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, V, \
439	- eval_fun1> >, eval_fun2> > \
440	- { \
441	- private: \
442	- typedef __gmp_expr<mpz_t, T> val1_type; \
443	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
444	- <__gmp_expr<mpz_t, U>, V, eval_fun1> > val2_type; \
445	- \
446	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
447	- public: \
448	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
449	- : expr(val1, val2) { } \
450	- void eval(mpz_ptr z) const \
451	- { \
452	- mpz_class temp1(expr.val1); \
453	- mpz_class temp2(expr.val2.get_val1()); \
454	- eval_both::eval \
455	- (z, temp1.get_mpz_t(), temp2.get_mpz_t(), expr.val2.get_val2()); \
456	- } \
457	- const val1_type & get_val1() const { return expr.val1; } \
458	- const val2_type & get_val2() const { return expr.val2; } \
459	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
460	- }; \
461	- \
462	- template <class T, class U, class V> \
463	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
464	- __gmp_expr<mpz_t, __gmp_binary_expr<U, __gmp_expr<mpz_t, V>, \
465	- eval_fun1> >, eval_fun2> > \
466	- { \
467	- private: \
468	- typedef __gmp_expr<mpz_t, T> val1_type; \
469	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
470	- <U, __gmp_expr<mpz_t, V>, eval_fun1> > val2_type; \
471	- \
472	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
473	- public: \
474	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
475	- : expr(val1, val2) { } \
476	- void eval(mpz_ptr z) const \
477	- { \
478	- mpz_class temp1(expr.val1); \
479	- mpz_class temp2(expr.val2.get_val2()); \
480	- eval_both::eval \
481	- (z, temp1.get_mpz_t(), expr.val2.get_val1(), temp2.get_mpz_t()); \
482	- } \
483	- const val1_type & get_val1() const { return expr.val1; } \
484	- const val2_type & get_val2() const { return expr.val2; } \
485	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
486	- }; \
487	- \
488	- template <class T, class U, class V> \
489	- class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
490	- __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, \
491	- __gmp_expr<mpz_t, V>, eval_fun1> >, eval_fun2> > \
492	- { \
493	- private: \
494	- typedef __gmp_expr<mpz_t, T> val1_type; \
495	- typedef __gmp_expr<mpz_t, __gmp_binary_expr \
496	- <__gmp_expr<mpz_t, U>, __gmp_expr<mpz_t, V>, eval_fun1> > val2_type; \
497	- \
498	- __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
499	- public: \
500	- __gmp_expr(const val1_type &val1, const val2_type &val2) \
501	- : expr(val1, val2) { } \
502	- void eval(mpz_ptr z) const \
503	- { \
504	- mpz_class temp1(expr.val1); \
505	- mpz_class temp2(expr.val2.get_val1()); \
506	- mpz_class temp3(expr.val2.get_val2()); \
507	- eval_both::eval \
508	- (z, temp1.get_mpz_t(), temp2.get_mpz_t(), temp3.get_mpz_t()); \
509	- } \
510	- const val1_type & get_val1() const { return expr.val1; } \
511	- const val2_type & get_val2() const { return expr.val2; } \
512	- unsigned long int get_prec() const { return mpf_get_default_prec(); } \
513	- };
514	-
515	-
516	- __GMP_DEFINE_TERNARY_EXPR(__gmp_binary_multiplies, __gmp_binary_plus,
517	- __gmp_ternary_addmul)
518	- __GMP_DEFINE_TERNARY_EXPR(__gmp_binary_multiplies, __gmp_binary_minus,
519	- __gmp_ternary_submul)
520
521	/************** Macros for defining functions **************/
522	--- 2777,2780 ----

Line 0 Link Here

(-)ports/math/libgmp4.new/files/patch-mpz_set_d (+15 lines)
	1	[2006-09-23] In mpz_set_d, arguments smaller than 1e-19 will trigger undefined behaviour, typically a crash. Note that this is a somewhat deegnerate use of mpz_set_d that should not normally happen, since any arguments < 1 will yield 0.
	2	http://www.swox.com/gmp/patches/mpz_set_d.diff
	3
	4	*** mpz/set_d.c 14 Mar 2006 15:57:54 -0000 1.1
	5	--- mpz/set_d.c 31 May 2006 14:50:05 -0000 1.2
	6	*************** mpz_set_d (mpz_ptr r, double d)
	7	* 57,60 **
	8	--- 58,64 ----
	9	_mpz_realloc (r, rn);
	10
	11	+ if (rn <= 0)
	12	+ rn = 0;
	13	+
	14	rp = PTR (r);
	15