number 0.9.4 → 0.9.5

data/ext/bounds.c

@@ -29,8 +29,7 @@ void bounds_free (Bounds* bounds)
     }
 }
 
-// add flag for EXACT calculation of mpfr, e.g. mpc_abs returns 0
-void bounds_update_re (Bounds* bounds, mpfr_t num, int re_closed)
+void bounds_update_re (Bounds* bounds, mpfr_t num, int re_closed, int exact)
 {
     int min_cmp;
     int max_cmp;
@@ -47,11 +46,12 @@ void bounds_update_re (Bounds* bounds, mpfr_t num, int re_closed)
     if (max_cmp != 1)
     {
         mpfr_set(bounds->re_max, num, MPFR_RNDN);
+        bounds->re_max_exact = exact;
         bounds->re_max_closed = (max_cmp) ? re_closed : bounds->re_max_closed || re_closed;
     }
 }
 
-void bounds_update_im (Bounds* bounds, mpfr_t num, int im_closed)
+void bounds_update_im (Bounds* bounds, mpfr_t num, int im_closed, int exact)
 {
     int min_cmp;
     int max_cmp;
@@ -68,11 +68,12 @@ void bounds_update_im (Bounds* bounds, mpfr_t num, int im_closed)
     if (max_cmp != 1)
     {
         mpfr_set(bounds->im_max, num, MPFR_RNDN);
+        bounds->im_max_exact = exact;
         bounds->im_max_closed = (max_cmp) ? im_closed : bounds->im_max_closed || im_closed;
     }
 }
 
-void bounds_update (Bounds* bounds, mpc_t num, int re_closed, int im_closed)
+void bounds_update (Bounds* bounds, mpc_t num, int re_closed, int im_closed, int mpc_inex)
 {
     mpfr_t re;
     mpfr_t im;
@@ -83,8 +84,8 @@ void bounds_update (Bounds* bounds, mpc_t num, int re_closed, int im_closed)
     mpc_real(re, num, MPFR_RNDN);
     mpc_imag(im, num, MPFR_RNDN);
     
-    bounds_update_re(bounds, re, re_closed);
-    bounds_update_im(bounds, im, im_closed);
+    bounds_update_re(bounds, re, re_closed, MPC_INEX_RE(mpc_inex) == 0);
+    bounds_update_im(bounds, im, im_closed, MPC_INEX_IM(mpc_inex) == 0);
     
     mpfr_clear(re);
     mpfr_clear(im);

data/ext/compare.c

@@ -1,6 +1,6 @@
 #include "number.h"
 
-int complex_re_contain_p (Complex* a, Complex* b)
+int complex_re_enclose_p (Complex* a, Complex* b)
 {
     return interval_span_p(a->re, b->re->l) && interval_span_p(a->re, b->re->u);
 }
@@ -355,7 +355,7 @@ int complex_im_contain_zero_p (Complex* complex)
     return interval_span_zero_p(complex->im);
 }
 
-int complex_im_contain_p (Complex* a, Complex* b)
+int complex_im_enclose_p (Complex* a, Complex* b)
 {
     return interval_span_p(a->im, b->im->l) && interval_span_p(a->im, b->im->u);
 }
@@ -620,9 +620,9 @@ int complex_im_u_le_u_p (Complex* a, Complex* b)
     return real_le_p(a->im->u, b->im->u);
 }
 
-int complex_contain_p (Complex* a, Complex* b)
+int complex_enclose_p (Complex* a, Complex* b)
 {
-    return complex_re_contain_p(a, b) && complex_im_contain_p(a, b);
+    return complex_re_enclose_p(a, b) && complex_im_enclose_p(a, b);
 }
 
 int complex_contain_ll_p (Complex* a, Complex* b)
@@ -657,7 +657,7 @@ int complex_contain_zero_p (Complex* complex)
 
 int complex_intersect_p (Complex* a, Complex* b)
 {
-    return (complex_re_intersect_p(a, b) && complex_im_intersect_p(a, b)) || complex_contain_ll_p(a, b) || complex_contain_lu_p(a, b) || complex_contain_ul_p(a, b) || complex_contain_uu_p(a, b) || (complex_re_contain_p(a, b) && complex_im_contain_p(b, a) || (complex_im_contain_p(a, b) && complex_re_contain_p(b, a)));
+    return (complex_re_intersect_p(a, b) && complex_im_intersect_p(a, b)) || complex_contain_ll_p(a, b) || complex_contain_lu_p(a, b) || complex_contain_ul_p(a, b) || complex_contain_uu_p(a, b) || (complex_re_enclose_p(a, b) && complex_im_enclose_p(b, a) || (complex_im_enclose_p(a, b) && complex_re_enclose_p(b, a)));
 }
 
 int complex_disjoint_p (Complex* a, Complex* b)

data/ext/complex.c

@@ -1,9 +1,73 @@
 #include "number.h"
 
+mpfr_t tmp_complex_from_float_str,
+       tmp_divide_re,
+       tmp_divide_im,
+       tmp_abs_n_re,
+       tmp_abs_ll_re,
+       tmp_abs_lu_re,
+       tmp_abs_ul_re,
+       tmp_abs_uu_re,
+       tmp_abs_re_abs,
+       tmp_abs_im_abs,
+       tmp_abs_zero,
+       tmp_diagonal,
+       tmp_sqrt_n_re,
+       tmp_sqrt_n_im;
+
+mpc_t tmp_divide_numerator,
+      tmp_divide_denominator,
+      tmp_divide_quotient,
+      tmp_abs_n,
+      tmp_abs_ll,
+      tmp_abs_lu,
+      tmp_abs_ul,
+      tmp_abs_uu,
+      tmp_sqrt_n,
+      tmp_sqrt_ll,
+      tmp_sqrt_lu,
+      tmp_sqrt_ul,
+      tmp_sqrt_uu,
+      tmp_sqrt_re_sqrt;
+
+void init_complex_tmp_nums ()
+{
+    mpfr_init2(tmp_complex_from_float_str, PREC);
+    mpfr_init2(tmp_divide_re, PREC);
+    mpfr_init2(tmp_divide_im, PREC);
+    mpfr_init2(tmp_abs_ll_re, PREC);
+    mpfr_init2(tmp_abs_n_re, PREC);
+    mpfr_init2(tmp_abs_ll_re, PREC);
+    mpfr_init2(tmp_abs_lu_re, PREC);
+    mpfr_init2(tmp_abs_ul_re, PREC);
+    mpfr_init2(tmp_abs_uu_re, PREC);
+    mpfr_init2(tmp_abs_re_abs, PREC);
+    mpfr_init2(tmp_abs_im_abs, PREC);
+    mpfr_init2(tmp_abs_zero, PREC);
+    mpfr_init2(tmp_diagonal, PREC);
+    mpfr_init2(tmp_sqrt_n_re, PREC);
+    mpfr_init2(tmp_sqrt_n_im, PREC);
+    
+    mpc_init2(tmp_divide_numerator, PREC);
+    mpc_init2(tmp_divide_denominator, PREC);
+    mpc_init2(tmp_divide_quotient, PREC);
+    mpc_init2(tmp_abs_n, PREC);
+    mpc_init2(tmp_abs_ll, PREC);
+    mpc_init2(tmp_abs_lu, PREC);
+    mpc_init2(tmp_abs_ul, PREC);
+    mpc_init2(tmp_abs_uu, PREC);
+    mpc_init2(tmp_sqrt_n, PREC);
+    mpc_init2(tmp_sqrt_ll, PREC);
+    mpc_init2(tmp_sqrt_lu, PREC);
+    mpc_init2(tmp_sqrt_ul, PREC);
+    mpc_init2(tmp_sqrt_uu, PREC);
+    mpc_init2(tmp_sqrt_re_sqrt, PREC);
+}
+
 /*
  *  Sets the value of num to the complex value represented by re and im.
  */
-void mpc_init_set_r_r (mpc_t num, Real* re, Real* im)
+void mpc_set_r_r (mpc_t num, Real* re, Real* im)
 {
     char buf[10000];
     char tmp_re_buf[10000];
@@ -21,7 +85,11 @@ void mpc_init_set_r_r (mpc_t num, Real* re, Real* im)
         sprintf(re_buf, "%s", NaN(re) ? "@nan@" : POS_INF(re) ? "@inf@" : "-@inf@");
     }
     
-    if (REAL(im))
+    if (!im)
+    {
+        sprintf(im_buf, "0");
+    }
+    else if (REAL(im))
     {
         gmp_sprintf(tmp_im_buf, "%+Zd", im->num);
         sprintf(im_buf, "%c0.%se%ld", *tmp_im_buf, tmp_im_buf + 1, im->exp);
@@ -32,15 +100,13 @@ void mpc_init_set_r_r (mpc_t num, Real* re, Real* im)
     }
     
     sprintf(buf, "(%s %s)", re_buf, im_buf);
-    
-    mpc_init2(num, PREC);
     mpc_set_str(num, buf, 10, MPC_RNDNN);
 }
 
 /*
  *  Sets the value of num to the floating point value represented by real.
  */
-void mpfr_init_set_r (mpfr_t num, Real* real)
+void mpfr_set_r (mpfr_t num, Real* real)
 {
     char sign;
     char buf[10000];
@@ -56,7 +122,6 @@ void mpfr_init_set_r (mpfr_t num, Real* real)
         sprintf(buf, "%s", NaN(real) ? "@nan@" : POS_INF(real) ? "@inf@" : "-@inf@");
     }
     
-    mpfr_init2(num, PREC);
     mpfr_set_str(num, buf, 10, MPFR_RNDN);
 }
 
@@ -171,17 +236,14 @@ Complex* complex_from_int_str (char* buf)
  */
 Complex* complex_from_float_str (char* buf)
 {
-    mpfr_t num;
     Real* real;
     Complex* result;
     
-    mpfr_init2(num, PREC);
-    mpfr_set_str(num, buf, 10, MPFR_RNDN);
+    mpfr_set_str(tmp_complex_from_float_str, buf, 10, MPFR_RNDN);
     
-    real = (Real*)real_from_mpfr(num, ROUND_NEAREST);
+    real = (Real*)real_from_mpfr(tmp_complex_from_float_str, ROUND_NEAREST);
     result = (Complex*)complex_from_real(real);
     
-    mpfr_clear(num);
     real_free(real);
     
     return result;
@@ -323,11 +385,6 @@ Complex* complex_multiply (Complex* a, Complex* b)
  */
 Complex* complex_divide (Complex* a, Complex* b)
 {
-    mpc_t num_numerator;
-    mpc_t num_denominator;
-    mpc_t num_quotient;
-    mpfr_t num_re;
-    mpfr_t num_im;
     Interval* denominator_re;
     Interval* denominator_im;
     Interval* denominator;
@@ -346,26 +403,22 @@ Complex* complex_divide (Complex* a, Complex* b)
     
     if (real_zero_p(denominator->l) || real_zero_p(denominator->u) || interval_span_zero_p(denominator))
     {
-        mpfr_init2(num_re, PREC);
-        mpfr_init2(num_im, PREC);
-        
-        mpc_init2(num_quotient, PREC);
-        mpc_init_set_r_r(num_numerator, a->re->n, a->im->n);
-        mpc_init_set_r_r(num_denominator, b->re->n, b->im->n);
+        mpfr_set_prec(tmp_divide_re, PREC);
+        mpfr_set_prec(tmp_divide_im, PREC);
+        mpc_set_prec(tmp_divide_quotient, PREC);
+        mpc_set_prec(tmp_divide_numerator, PREC);
+        mpc_set_prec(tmp_divide_denominator, PREC);
         
-        mpc_div(num_quotient, num_numerator, num_denominator, MPC_RNDNN);
+        mpc_set_r_r(tmp_divide_numerator, a->re->n, a->im->n);
+        mpc_set_r_r(tmp_divide_denominator, b->re->n, b->im->n);
         
-        mpc_real(num_re, num_quotient, MPFR_RNDN);
-        mpc_imag(num_im, num_quotient, MPFR_RNDN);
+        mpc_div(tmp_divide_quotient, tmp_divide_numerator, tmp_divide_denominator, MPC_RNDNN);
         
-        re = (Interval*)interval_new((Real*)real_neg_inf(), true, (Real*)real_from_mpfr(num_re, ROUND_NEAREST), true, (Real*)real_pos_inf());
-        im = (Interval*)interval_new((Real*)real_neg_inf(), true, (Real*)real_from_mpfr(num_im, ROUND_NEAREST), true, (Real*)real_pos_inf());
+        mpc_real(tmp_divide_re, tmp_divide_quotient, MPFR_RNDN);
+        mpc_imag(tmp_divide_im, tmp_divide_quotient, MPFR_RNDN);
         
-        mpc_clear(num_numerator);
-        mpc_clear(num_denominator);
-        mpc_clear(num_quotient);
-        mpfr_clear(num_re);
-        mpfr_clear(num_im);
+        re = (Interval*)interval_new((Real*)real_neg_inf(), true, (Real*)real_from_mpfr(tmp_divide_re, ROUND_NEAREST), true, (Real*)real_pos_inf());
+        im = (Interval*)interval_new((Real*)real_neg_inf(), true, (Real*)real_from_mpfr(tmp_divide_im, ROUND_NEAREST), true, (Real*)real_pos_inf());
     }
     else
     {
@@ -415,102 +468,83 @@ Complex* complex_modulo (Complex* a, Complex* b)
  */
 Complex* complex_abs (Complex* complex)
 {
-    mpfr_t num_n_re;
-    mpfr_t num_ll_re;
-    mpfr_t num_lu_re;
-    mpfr_t num_ul_re;
-    mpfr_t num_uu_re;
-    mpfr_t num_re_abs;
-    mpfr_t num_im_abs;
-    mpc_t num_n;
-    mpc_t num_ll;
-    mpc_t num_lu;
-    mpc_t num_ul;
-    mpc_t num_uu;
-    Real* re_l_abs;
-    Real* re_u_abs;
-    Real* im_l_abs;
-    Real* im_u_abs;
-    
+    int ll_mpc_ternary;
+    int lu_mpc_ternary;
+    int ul_mpc_ternary;
+    int uu_mpc_ternary;
+    Real* l_abs;
+    Real* u_abs;
     Bounds* bounds;
     Interval* re;
     
-    mpfr_init2(num_n_re, PREC);
-    mpfr_init2(num_ll_re, PREC);
-    mpfr_init2(num_lu_re, PREC);
-    mpfr_init2(num_ul_re, PREC);
-    mpfr_init2(num_uu_re, PREC);
-    
-    mpc_init_set_r_r(num_n, complex->re->n, complex->im->n);
-    mpc_abs(num_n_re, num_n, MPC_RNDNN);
-    
-    mpc_init_set_r_r(num_ll, complex->re->l, complex->im->l);
-    mpc_init_set_r_r(num_lu, complex->re->l, complex->im->u);
-    mpc_init_set_r_r(num_ul, complex->re->u, complex->im->l);
-    mpc_init_set_r_r(num_uu, complex->re->u, complex->im->u);
-    
-    mpc_abs(num_ll_re, num_ll, MPC_RNDDD);
-    mpc_abs(num_lu_re, num_lu, MPC_RNDDU);
-    mpc_abs(num_ul_re, num_ul, MPC_RNDUD);
-    mpc_abs(num_uu_re, num_uu, MPC_RNDUU);
-    
-    mpc_clear(num_n);
-    mpc_clear(num_ll);
-    mpc_clear(num_lu);
-    mpc_clear(num_ul);
-    mpc_clear(num_uu);
+    mpfr_set_prec(tmp_abs_n_re, PREC);
+    mpfr_set_prec(tmp_abs_ll_re, PREC);
+    mpfr_set_prec(tmp_abs_lu_re, PREC);
+    mpfr_set_prec(tmp_abs_ul_re, PREC);
+    mpfr_set_prec(tmp_abs_uu_re, PREC);
+    mpfr_set_prec(tmp_abs_re_abs, PREC);
+    mpfr_set_prec(tmp_abs_im_abs, PREC);
+    mpfr_set_prec(tmp_abs_zero, PREC);
+    mpc_set_prec(tmp_abs_n, PREC);
+    mpc_set_prec(tmp_abs_ll, PREC);
+    mpc_set_prec(tmp_abs_lu, PREC);
+    mpc_set_prec(tmp_abs_ul, PREC);
+    mpc_set_prec(tmp_abs_uu, PREC);
+    
+    mpc_set_r_r(tmp_abs_n, complex->re->n, complex->im->n);
+    mpc_abs(tmp_abs_n_re, tmp_abs_n, MPC_RNDNN);
+    
+    mpc_set_r_r(tmp_abs_ll, complex->re->l, complex->im->l);
+    mpc_set_r_r(tmp_abs_lu, complex->re->l, complex->im->u);
+    mpc_set_r_r(tmp_abs_ul, complex->re->u, complex->im->l);
+    mpc_set_r_r(tmp_abs_uu, complex->re->u, complex->im->u);
+    
+    ll_mpc_ternary = mpc_abs(tmp_abs_ll_re, tmp_abs_ll, MPC_RNDDD);
+    lu_mpc_ternary = mpc_abs(tmp_abs_lu_re, tmp_abs_lu, MPC_RNDDU);
+    ul_mpc_ternary = mpc_abs(tmp_abs_ul_re, tmp_abs_ul, MPC_RNDUD);
+    uu_mpc_ternary = mpc_abs(tmp_abs_uu_re, tmp_abs_uu, MPC_RNDUU);
     
     bounds = (Bounds*)bounds_new();
-    bounds_update_re(bounds, num_ll_re, complex->re->L);
-    bounds_update_re(bounds, num_lu_re, complex->re->L);
-    bounds_update_re(bounds, num_ul_re, complex->re->R);
-    bounds_update_re(bounds, num_uu_re, complex->re->R);
+    bounds_update_re(bounds, tmp_abs_ll_re, complex->re->L, MPC_INEX_RE(ll_mpc_ternary) == 0);
+    bounds_update_re(bounds, tmp_abs_lu_re, complex->re->L, MPC_INEX_RE(lu_mpc_ternary) == 0);
+    bounds_update_re(bounds, tmp_abs_ul_re, complex->re->R, MPC_INEX_RE(ul_mpc_ternary) == 0);
+    bounds_update_re(bounds, tmp_abs_uu_re, complex->re->R, MPC_INEX_RE(uu_mpc_ternary) == 0);
     
     if (interval_span_zero_p(complex->im))
     {
-        re_l_abs = (Real*)real_abs(complex->re->l);
-        re_u_abs = (Real*)real_abs(complex->re->u);
+        l_abs = (Real*)real_abs(complex->re->l);
+        u_abs = (Real*)real_abs(complex->re->u);
         
-        mpfr_init_set_r(num_re_abs, real_lt_p(re_l_abs, re_u_abs) ? re_l_abs : re_u_abs);
-        bounds_update_re(bounds, num_re_abs, true);
+        mpfr_set_r(tmp_abs_re_abs, real_lt_p(l_abs, u_abs) ? l_abs : u_abs);
+        bounds_update_re(bounds, tmp_abs_re_abs, true, true);
         
-        real_free(re_l_abs);
-        real_free(re_u_abs);
-        
-        mpfr_clear(num_re_abs);
+        real_free(l_abs);
+        real_free(u_abs);
     }
     
     if (interval_span_zero_p(complex->re))
     {
-        im_l_abs = (Real*)real_abs(complex->im->l);
-        im_u_abs = (Real*)real_abs(complex->im->u);
-        
-        mpfr_init_set_r(num_im_abs, real_lt_p(im_l_abs, im_u_abs) ? im_l_abs : im_u_abs);
-        bounds_update_re(bounds, num_im_abs, true);
+        l_abs = (Real*)real_abs(complex->im->l);
+        u_abs = (Real*)real_abs(complex->im->u);
         
-        real_free(im_l_abs);
-        real_free(im_u_abs);
+        mpfr_set_r(tmp_abs_im_abs, real_lt_p(l_abs, u_abs) ? l_abs : u_abs);
+        bounds_update_re(bounds, tmp_abs_im_abs, true, true);
         
-        mpfr_clear(num_im_abs);
+        real_free(l_abs);
+        real_free(u_abs);
     }
     
     if (interval_span_zero_p(complex->re) && interval_span_zero_p(complex->im))
     {
-        mpfr_set_zero(num_ll_re, 1);
-        bounds_update_re(bounds, num_ll_re, true);
+        mpfr_set_zero(tmp_abs_zero, 1);
+        bounds_update_re(bounds, tmp_abs_zero, true, true);
     }
     
-    re = (Interval*)interval_new(real_from_mpfr(bounds->re_min, ROUND_DOWN), bounds->re_min_closed, real_from_mpfr(num_n_re, ROUND_NEAREST), bounds->re_max_closed, real_from_mpfr(bounds->re_max, ROUND_UP1));
+    re = (Interval*)interval_new(real_from_mpfr(bounds->re_min, ROUND_DOWN), bounds->re_min_closed, real_from_mpfr(tmp_abs_n_re, ROUND_NEAREST), bounds->re_max_closed, real_from_mpfr(bounds->re_max, bounds->re_max_exact ? ROUND_UP : ROUND_UP1));
     
     bounds_free(bounds);
     
-    mpfr_clear(num_n_re);
-    mpfr_clear(num_ll_re);
-    mpfr_clear(num_lu_re);
-    mpfr_clear(num_ul_re);
-    mpfr_clear(num_uu_re);
-    
-    return complex_new(re, (Interval*)interval_zero());
+    return (Complex*)complex_new(re, (Interval*)interval_zero());
 }
 
 /*
@@ -542,7 +576,7 @@ Complex* complex_area (Complex* complex)
  */
 Complex* complex_diagonal (Complex* complex)
 {
-    mpfr_t num_diag;
+    int mpfr_ternary;
     Real* re_width;
     Real* im_width;
     Real* re_width2;
@@ -559,10 +593,10 @@ Complex* complex_diagonal (Complex* complex)
     
     diag2 = (Real*)real_add(re_width2, im_width2);
     
-    mpfr_init_set_r(num_diag, diag2);
-    mpfr_sqrt(num_diag, num_diag, MPFR_RNDN);
+    mpfr_set_r(tmp_diagonal, diag2);
+    mpfr_ternary = mpfr_sqrt(tmp_diagonal, tmp_diagonal, MPFR_RNDN);
     
-    re = (Interval*)interval_new((Real*)real_from_mpfr(num_diag, ROUND_DOWN), true, (Real*)real_from_mpfr(num_diag, ROUND_NEAREST), true, (Real*)real_from_mpfr(num_diag, ROUND_UP1));
+    re = (Interval*)interval_new((Real*)real_from_mpfr(tmp_diagonal, ROUND_DOWN), true, (Real*)real_from_mpfr(tmp_diagonal, ROUND_NEAREST), true, (Real*)real_from_mpfr(tmp_diagonal, (mpfr_ternary == 0) ? ROUND_UP : ROUND_UP1));
     
     real_free(re_width);
     real_free(im_width);
@@ -570,8 +604,6 @@ Complex* complex_diagonal (Complex* complex)
     real_free(im_width2);
     real_free(diag2);
     
-    mpfr_clear(num_diag);
-    
     return (Complex*)complex_new(re, (Interval*)interval_zero());
 }
 
@@ -581,7 +613,7 @@ Complex* complex_diagonal (Complex* complex)
  */
 Complex* complex_conjugate (Complex* complex)
 {
-    return complex_new((Interval*)interval_dup(complex->re), (Interval*)interval_negate(complex->im));
+    return (Complex*)complex_new((Interval*)interval_dup(complex->re), (Interval*)interval_negate(complex->im));
 }
 
 /*
@@ -589,7 +621,7 @@ Complex* complex_conjugate (Complex* complex)
  */
 Complex* complex_negate (Complex* complex)
 {
-    return complex_new((Interval*)interval_negate(complex->re), (Interval*)interval_negate(complex->im));
+    return (Complex*)complex_new((Interval*)interval_negate(complex->re), (Interval*)interval_negate(complex->im));
 }
 
 /*
@@ -598,7 +630,7 @@ Complex* complex_negate (Complex* complex)
  */
 Complex* complex_reflect (Complex* complex)
 {
-    return complex_new((Interval*)interval_dup(complex->im), (Interval*)interval_dup(complex->re));
+    return (Complex*)complex_new((Interval*)interval_dup(complex->im), (Interval*)interval_dup(complex->re));
 }
 
 /*
@@ -606,69 +638,57 @@ Complex* complex_reflect (Complex* complex)
  */
 Complex* complex_sqrt (Complex* complex)
 {
-    mpfr_t num_n_re;
-    mpfr_t num_n_im;
-    mpc_t num_n;
-    mpc_t num_ll;
-    mpc_t num_lu;
-    mpc_t num_ul;
-    mpc_t num_uu;
-    mpc_t num_re_sqrt;
-    Real* zero;
+    int ll_mpc_ternary;
+    int lu_mpc_ternary;
+    int ul_mpc_ternary;
+    int uu_mpc_ternary;
+    int re_sqrt_mpc_ternary;
     Bounds* bounds;
     Interval* re;
     Interval* im;
     
-    mpfr_init2(num_n_re, PREC);
-    mpfr_init2(num_n_im, PREC);
-    
-    mpc_init_set_r_r(num_n, complex->re->n, complex->im->n);
-    mpc_sqrt(num_n, num_n, MPC_RNDNN);
-    mpc_real(num_n_re, num_n, MPFR_RNDN);
-    mpc_imag(num_n_im, num_n, MPFR_RNDN);
-    
-    mpc_init_set_r_r(num_ll, complex->re->l, complex->im->l);
-    mpc_init_set_r_r(num_lu, complex->re->l, complex->im->u);
-    mpc_init_set_r_r(num_ul, complex->re->u, complex->im->l);
-    mpc_init_set_r_r(num_uu, complex->re->u, complex->im->u);
-    
-    mpc_sqrt(num_ll, num_ll, MPC_RNDDD);
-    mpc_sqrt(num_lu, num_lu, MPC_RNDDU);
-    mpc_sqrt(num_ul, num_ul, MPC_RNDUD);
-    mpc_sqrt(num_uu, num_uu, MPC_RNDUU);
+    mpfr_set_prec(tmp_sqrt_n_re, PREC);
+    mpfr_set_prec(tmp_sqrt_n_im, PREC);
+    mpc_set_prec(tmp_sqrt_n, PREC);
+    mpc_set_prec(tmp_sqrt_ll, PREC);
+    mpc_set_prec(tmp_sqrt_lu, PREC);
+    mpc_set_prec(tmp_sqrt_ul, PREC);
+    mpc_set_prec(tmp_sqrt_uu, PREC);
+    mpc_set_prec(tmp_sqrt_re_sqrt, PREC);
+    
+    mpc_set_r_r(tmp_sqrt_n, complex->re->n, complex->im->n);
+    mpc_sqrt(tmp_sqrt_n, tmp_sqrt_n, MPC_RNDNN);
+    mpc_real(tmp_sqrt_n_re, tmp_sqrt_n, MPFR_RNDN);
+    mpc_imag(tmp_sqrt_n_im, tmp_sqrt_n, MPFR_RNDN);
+    
+    mpc_set_r_r(tmp_sqrt_ll, complex->re->l, complex->im->l);
+    mpc_set_r_r(tmp_sqrt_lu, complex->re->l, complex->im->u);
+    mpc_set_r_r(tmp_sqrt_ul, complex->re->u, complex->im->l);
+    mpc_set_r_r(tmp_sqrt_uu, complex->re->u, complex->im->u);
+    
+    ll_mpc_ternary = mpc_sqrt(tmp_sqrt_ll, tmp_sqrt_ll, MPC_RNDDD);
+    lu_mpc_ternary = mpc_sqrt(tmp_sqrt_lu, tmp_sqrt_lu, MPC_RNDDU);
+    ul_mpc_ternary = mpc_sqrt(tmp_sqrt_ul, tmp_sqrt_ul, MPC_RNDUD);
+    uu_mpc_ternary = mpc_sqrt(tmp_sqrt_uu, tmp_sqrt_uu, MPC_RNDUU);
     
     bounds = (Bounds*)bounds_new();
-    bounds_update(bounds, num_ll, complex->re->L, complex->im->L);
-    bounds_update(bounds, num_lu, complex->re->L, complex->im->R);
-    bounds_update(bounds, num_ul, complex->re->R, complex->im->L);
-    bounds_update(bounds, num_uu, complex->re->R, complex->im->R);
+    bounds_update(bounds, tmp_sqrt_ll, complex->re->L, complex->im->L, ll_mpc_ternary);
+    bounds_update(bounds, tmp_sqrt_lu, complex->re->L, complex->im->R, lu_mpc_ternary);
+    bounds_update(bounds, tmp_sqrt_ul, complex->re->R, complex->im->L, ul_mpc_ternary);
+    bounds_update(bounds, tmp_sqrt_uu, complex->re->R, complex->im->R, uu_mpc_ternary);
     
     if (interval_span_zero_p(complex->im))
     {
-        zero = (Real*)real_zero();
-        
-        mpc_init_set_r_r(num_re_sqrt, complex->re->l, zero);
-        mpc_sqrt(num_re_sqrt, num_re_sqrt, MPC_RNDDD);
+        mpc_set_r_r(tmp_sqrt_re_sqrt, complex->re->l, 0);
+        re_sqrt_mpc_ternary = mpc_sqrt(tmp_sqrt_re_sqrt, tmp_sqrt_re_sqrt, MPC_RNDDD);
         
-        bounds_update(bounds, num_re_sqrt, complex->re->L);
-        
-        real_free(zero);
-        mpc_clear(num_re_sqrt);
+        bounds_update(bounds, tmp_sqrt_re_sqrt, complex->re->L, true, re_sqrt_mpc_ternary);
     }
     
-    re = (Interval*)interval_new(real_from_mpfr(bounds->re_min, ROUND_DOWN), bounds->re_min_closed, real_from_mpfr(num_n_re, ROUND_NEAREST), bounds->re_max_closed, real_from_mpfr(bounds->re_max, ROUND_UP1));
-    im = (Interval*)interval_new(real_from_mpfr(bounds->im_min, ROUND_DOWN), bounds->im_min_closed, real_from_mpfr(num_n_im, ROUND_NEAREST), bounds->im_max_closed, real_from_mpfr(bounds->im_max, ROUND_UP1));
+    re = (Interval*)interval_new((Real*)real_from_mpfr(bounds->re_min, ROUND_DOWN), bounds->re_min_closed, (Real*)real_from_mpfr(tmp_sqrt_n_re, ROUND_NEAREST), bounds->re_max_closed, (Real*)real_from_mpfr(bounds->re_max, bounds->re_max_exact ? ROUND_UP : ROUND_UP1));
+    im = (Interval*)interval_new((Real*)real_from_mpfr(bounds->im_min, ROUND_DOWN), bounds->im_min_closed, (Real*)real_from_mpfr(tmp_sqrt_n_im, ROUND_NEAREST), bounds->im_max_closed, (Real*)real_from_mpfr(bounds->im_max, bounds->im_max_exact ? ROUND_UP : ROUND_UP1));
     
     bounds_free(bounds);
     
-    mpfr_clear(num_n_re);
-    mpfr_clear(num_n_im);
-    
-    mpc_clear(num_n);
-    mpc_clear(num_ll);
-    mpc_clear(num_lu);
-    mpc_clear(num_ul);
-    mpc_clear(num_uu);
-    
-    return complex_new(re, im);
+    return (Complex*)complex_new(re, im);
 }

data/ext/interval.c

@@ -335,7 +335,7 @@ Interval* interval_divide (Interval* a, Interval* b)
     L = bounds->min_closed;
     R = bounds->max_closed;
     
-    n = (Real*)real_divide(a->n, b->n);
+    n = (Real*)real_divide(a->n, b->n, ROUND_NEAREST);
     l = (Real*)real_dup(bounds->min);
     u = (Real*)real_dup(bounds->max);
     

data/ext/number.c

@@ -1351,10 +1351,11 @@ VALUE rb_Number_complex_bounds_eq_p (VALUE a, VALUE b)
 
 void Init_number ()
 {
-    init_tmp_nums();
-    
     digs = 17;
     
+    init_real_tmp_nums();
+    init_complex_tmp_nums();
+    
     rb_define_method(rb_cString, "to_number", rb_String_to_number, 0);
     rb_define_method(rb_cInteger, "to_number", rb_Integer_to_number, 0);
     rb_define_method(rb_cFloat, "to_number", rb_Float_to_number, 0);

data/ext/number.h

@@ -59,8 +59,10 @@ typedef struct
 {
     int re_min_closed;
     int re_max_closed;
+    int re_max_exact;
     int im_min_closed;
     int im_max_closed;
+    int im_max_exact;
     mpfr_t re_min;
     mpfr_t re_max;
     mpfr_t im_min;

data/ext/real.c

@@ -26,7 +26,7 @@ mpz_t a_tmp,
 /*
  *  Initializes mpz_t variables for use in Real functions.
  */
-void init_tmp_nums ()
+void init_real_tmp_nums ()
 {
     mpz_init(a_tmp);
     mpz_init(b_tmp);
@@ -796,22 +796,28 @@ Real* real_divide (Real* a, Real* b, int round_mode)
     mpfr_t a_num;
     mpfr_t b_num;
     mpfr_t num;
+    Real* result;
     
     if (!REAL(a) || !REAL(b))
     {
         return (NaN(a) || NaN(b) || (!REAL(a) && !REAL(b))) ? real_nan() : !REAL(b) ? real_zero() : (POS(a) && POS(b)) ? real_pos_inf() : real_neg_inf();
     }
     
-    mpfr_init2(num, PREC);
-    mpfr_init_set_r(a_num, a);
-    mpfr_init_set_r(b_num, b);
+    mpfr_init2(a_num, PREC);
+    mpfr_init2(b_num, PREC);
+    mpfr_set_r(a_num, a);
+    mpfr_set_r(b_num, b);
     
+    mpfr_init2(num, PREC);
     mpfr_div(num, a_num, b_num, MPFR_RNDN);
     
+    result = (Real*)real_from_mpfr(num, round_mode);
+    
     mpfr_clear(a_num);
     mpfr_clear(b_num);
+    mpfr_clear(num);
     
-    return (Real*)real_from_mpfr(num, round_mode);
+    return result;
 }
 
 //{

metadata

@@ -2,7 +2,7 @@
 name: number
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors: 
 - Jesse Sielaff
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-16 00:00:00 Z
+date: 2011-07-17 00:00:00 Z
 dependencies: []
 
 description: The Number gem is intended to be a drop-in replacement for Ruby's Numeric classes when arbitrary-precision complex interval calculations are warranted. The basis of the arbitrary-precision calculations is the GNU MP, MPFR, and MPC libraries.
@@ -24,7 +24,6 @@ extensions:
 extra_rdoc_files: []
 
 files: 
-- README
 - ext/bounds.c
 - ext/compare.c
 - ext/complex.c

data/README

@@ -1,13 +0,0 @@
-Use the global function Number() to create Number objects.
-  
-  Number(1)
-  Number(1,2)
-  Number(1,2,3)
-  Number(Number(1,2,3), Number(4,5,6))
-  
-Number objects coerce Numeric objects into Number objects.
-  
-  Number(1) + 1
-  5 / Number(1,2,3)
-  
-Stay tuned. More documentation to come.