number 0.9.9 → 0.9.10

data/ext/number/real.c

@@ -170,22 +170,16 @@ void real_print (char* buf, Real* real)
  */
 void real_pad_tmps (Real* a, Real* b, long* exp, long* len)
 {
-    long a_len;
-    long b_len;
-    long a_last_place;
-    long b_last_place;
-    long pad;
-    
     mpz_set(a_tmp, a->num);
     mpz_set(b_tmp, b->num);
     
-    a_len = num_len(a_tmp);
-    b_len = num_len(b_tmp);
+    long a_len = num_len(a_tmp);
+    long b_len = num_len(b_tmp);
     
-    a_last_place = 1 + a->exp - a_len;
-    b_last_place = 1 + b->exp - b_len;
+    long a_last_place = 1 + a->exp - a_len;
+    long b_last_place = 1 + b->exp - b_len;
     
-    pad = a_last_place - b_last_place;
+    long pad = a_last_place - b_last_place;
     
     if (pad > 0)
     {
@@ -231,8 +225,6 @@ int real_positive_p (Real* real)
  */
 int real_cmp (Real* a, Real* b)
 {
-    int a_sign;
-    int b_sign;
     long exp;
     long len;
     
@@ -241,8 +233,8 @@ int real_cmp (Real* a, Real* b)
         return (NaN(a) || NaN(b)) ? 0 : POS_INF(a) ? (POS_INF(b) ? 0 : 1) : POS_INF(b) ? -1 : NEG_INF(a) ? (NEG_INF(b) ? 0 : -1) : 1;
     }
     
-    a_sign = mpz_sgn(a->num);
-    b_sign = mpz_sgn(b->num);
+    int a_sign = mpz_sgn(a->num);
+    int b_sign = mpz_sgn(b->num);
     
     if (a_sign != b_sign)
     {
@@ -303,8 +295,7 @@ int real_le_p (Real* a, Real* b)
  */
 Real* real_alloc ()
 {
-    Real* real;
-    real = malloc(sizeof(Real));
+    Real* real = malloc(sizeof(Real));
     
     if (real == NULL)
     {
@@ -325,8 +316,7 @@ Real* real_alloc ()
  */
 Real* real_new_flagged (int flag)
 {
-    Real* real;
-    real = real_alloc();
+    Real* real = real_alloc();
     
     real->exp = 0;
     real->flag = flag;
@@ -344,8 +334,7 @@ Real* real_new_flagged (int flag)
  */
 Real* real_new_exact (mpz_t num, long exp)
 {
-    Real* real;
-    real = real_alloc();
+    Real* real = real_alloc();
     
     real->exp = exp;
     real->flag = 0;
@@ -360,22 +349,17 @@ Real* real_new_exact (mpz_t num, long exp)
     
     mpz_set(real->num, num);
     
-    if (mpz_sgn(real->num))
+    if (mpz_sgn(real->num) == 0)
+    {
+        real->exp = 0;
+    }
+    else
     {
-        while (mpz_divisible_ui_p(real->num, 10000))
-        {
-            mpz_divexact_ui(real->num, real->num, 10000);
-        }
-        
         while (mpz_divisible_ui_p(real->num, 10))
         {
             mpz_divexact_ui(real->num, real->num, 10);
         }
     }
-    else
-    {
-        real->exp = 0;
-    }
     
     return real;
 }
@@ -392,13 +376,10 @@ Real* real_new_exact (mpz_t num, long exp)
  */
 Real* real_new_rounded (mpz_t num, long exp, int round_mode)
 {
-    long len;
-    long overrun;
-    
     mpz_set(tmp_real_new_rounded, num);
     
-    len = num_len(num);
-    overrun = len - digs;
+    long len = num_len(num);
+    long overrun = len - digs;
     
     if (overrun > 0)
     {
@@ -578,15 +559,12 @@ Real* real_negate (Real* real)
  */
 Real* real_ceil (Real* real)
 {
-    long len;
-    long dec;
-    
     REAL_CHECK(real);
     
     mpz_set(tmp_real_ceil, real->num);
     
-    len = num_len(tmp_real_ceil);
-    dec = len - real->exp;
+    long len = num_len(tmp_real_ceil);
+    long dec = len - real->exp;
     
     if (dec > 0)
     {
@@ -606,15 +584,12 @@ Real* real_ceil (Real* real)
  */
 Real* real_floor (Real* real)
 {
-    long len;
-    long dec;
-    
     REAL_CHECK(real);
     
     mpz_set(tmp_real_floor, real->num);
     
-    len = num_len(tmp_real_floor);
-    dec = len - real->exp;
+    long len = num_len(tmp_real_floor);
+    long dec = len - real->exp;
     
     if (dec > 0)
     {
@@ -634,15 +609,12 @@ Real* real_floor (Real* real)
  */
 Real* real_round (Real* real)
 {
-    long len;
-    long dec;
-    
     REAL_CHECK(real);
     
     mpz_set(tmp_real_round, real->num);
     
-    len = num_len(tmp_real_round);
-    dec = len - real->exp;
+    long len = num_len(tmp_real_round);
+    long dec = len - real->exp;
     
     if (dec > 0)
     {
@@ -662,15 +634,12 @@ Real* real_round (Real* real)
  */
 Real* real_round_infinity (Real* real)
 {
-    long len;
-    long dec;
-    
     REAL_CHECK(real);
     
     mpz_set(tmp_real_round_infinity, real->num);
     
-    len = num_len(tmp_real_round_infinity);
-    dec = len - real->exp;
+    long len = num_len(tmp_real_round_infinity);
+    long dec = len - real->exp;
     
     if (dec > 0)
     {
@@ -690,15 +659,12 @@ Real* real_round_infinity (Real* real)
  */
 Real* real_round_origin (Real* real)
 {
-    long len;
-    long dec;
-    
     REAL_CHECK(real);
     
     mpz_set(tmp_real_round_origin, real->num);
     
-    len = num_len(tmp_real_round_origin);
-    dec = len - real->exp;
+    long len = num_len(tmp_real_round_origin);
+    long dec = len - real->exp;
     
     if (dec > 0)
     {
@@ -764,21 +730,16 @@ Real* real_subtract  (Real* a, Real* b)
  */
 Real* real_multiply (Real* a, Real* b)
 {
-    long a_len;
-    long b_len;
-    long exp;
-    long dec;
-    
     if (!REAL(a) || !REAL(b))
     {
         return (NaN(a) || NaN(b) || ZERO(a) || ZERO(b)) ? real_nan() : ((POS(a) && POS(b)) || (NEG(a) && NEG(b))) ? real_pos_inf() : real_neg_inf();
     }
     
-    a_len = num_len(a->num);
-    b_len = num_len(b->num);
+    long a_len = num_len(a->num);
+    long b_len = num_len(b->num);
     
     mpz_mul(tmp_real_multiply, a->num, b->num);
-    exp = num_len(tmp_real_multiply) - ((a_len - a->exp) + (b_len - b->exp));
+    long exp = num_len(tmp_real_multiply) - ((a_len - a->exp) + (b_len - b->exp));
     
     return real_new_exact(tmp_real_multiply, exp);
 }
@@ -796,7 +757,6 @@ 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))
     {
@@ -811,7 +771,7 @@ Real* real_divide (Real* a, Real* b, int round_mode)
     mpfr_init2(num, PREC);
     mpfr_div(num, a_num, b_num, MPFR_RNDN);
     
-    result = real_from_mpfr(num, round_mode);
+    Real* result = real_from_mpfr(num, round_mode);
     
     mpfr_clear(a_num);
     mpfr_clear(b_num);

data/ext/number/real_bounds.c

@@ -24,7 +24,7 @@ void real_bounds_update (RealBounds* bounds, Real* real, int closed)
     int min_cmp;
     int max_cmp;
     
-    if (!bounds->min || (min_cmp = real_cmp(bounds->min, real)) != -1)
+    if (min_cmp = real_cmp(bounds->min, real) != -1)
     {
         real_free(bounds->min);
         
@@ -32,7 +32,7 @@ void real_bounds_update (RealBounds* bounds, Real* real, int closed)
         bounds->min_closed = (min_cmp) ? closed : bounds->min_closed || closed;
     }
     
-    if (!bounds->max || (max_cmp = real_cmp(bounds->max, real)) != 1)
+    if (max_cmp = real_cmp(bounds->max, real) != 1)
     {
         real_free(bounds->max);
         
@@ -45,8 +45,7 @@ void real_bounds_update (RealBounds* bounds, Real* real, int closed)
 
 RealBounds* real_bounds_new ()
 {
-    RealBounds* bounds;
-    bounds = malloc(sizeof(RealBounds));
+    RealBounds* bounds = malloc(sizeof(RealBounds));
     
     if (bounds == NULL)
     {
@@ -54,4 +53,9 @@ RealBounds* real_bounds_new ()
     }
     
     memset(bounds, 0, sizeof(RealBounds));
+    
+    bounds->min = real_pos_inf();
+    bounds->max = real_neg_inf();
+    
+    return bounds;
 }

data/ext/number/round.c

@@ -2,45 +2,72 @@
 
 Complex* complex_round (Complex* complex)
 {
-    return complex_new(interval_round(complex->re), interval_round(complex->im));
+    Interval* re = interval_round(complex->re);
+    Interval* im = interval_round(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_c_c (Complex* complex)
 {
-    return complex_new(interval_round_ceiling(complex->re), interval_round_ceiling(complex->im));
+    Interval* re = interval_round_ceiling(complex->re);
+    Interval* im = interval_round_ceiling(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_c_f (Complex* complex)
 {
-    return complex_new(interval_round_floor(complex->re), interval_round_ceiling(complex->im));
+    Interval* re = interval_round_ceiling(complex->re);
+    Interval* im = interval_round_floor(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_f_c (Complex* complex)
 {
-    return complex_new(interval_round_ceiling(complex->re), interval_round_floor(complex->im));
+    Interval* re = interval_round_floor(complex->re);
+    Interval* im = interval_round_ceiling(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_f_f (Complex* complex)
 {
-    return complex_new(interval_round_floor(complex->re), interval_round_floor(complex->im));
+    Interval* re = interval_round_floor(complex->re);
+    Interval* im = interval_round_floor(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_i_i (Complex* complex)
 {
-    return complex_new(interval_round_infinity(complex->re), interval_round_infinity(complex->im));
+    Interval* re = interval_round_infinity(complex->re);
+    Interval* im = interval_round_infinity(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_i_o (Complex* complex)
 {
-    return complex_new(interval_round_infinity(complex->re), interval_round_origin(complex->im));
+    Interval* re = interval_round_infinity(complex->re);
+    Interval* im = interval_round_origin(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_o_i (Complex* complex)
 {
-    return complex_new(interval_round_origin(complex->re), interval_round_infinity(complex->im));
+    Interval* re = interval_round_origin(complex->re);
+    Interval* im = interval_round_infinity(complex->im);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_round_o_o (Complex* complex)
 {
-    return complex_new(interval_round_origin(complex->re), interval_round_origin(complex->im));
+    Interval* re = interval_round_origin(complex->re);
+    Interval* im = interval_round_origin(complex->im);
+    
+    return complex_new(re, im);
 }

metadata

@@ -2,7 +2,7 @@
 name: number
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors: 
 - Jesse Sielaff
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-10 00:00:00 Z
+date: 2011-09-02 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.
@@ -60,7 +60,7 @@ requirements:
 - MPFR
 - MPC
 rubyforge_project: 
-rubygems_version: 1.8.7
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: An arbitrary-precision complex interval number library for Ruby.