number 0.9.9 → 0.9.10

data/ext/number/decompose.c

@@ -2,230 +2,293 @@
 
 Complex* complex_im (Complex* complex)
 {
-    return complex_new(interval_dup(complex->im), interval_zero());
+    Interval* re = interval_dup(complex->im);
+    Interval* im = interval_zero();
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_im_l (Complex* complex)
 {
-    return complex_from_real(complex->im->l);
+    Real* real = real_dup(complex->im->l);
+    return complex_from_real(real);
 }
 
 Complex* complex_im_n (Complex* complex)
 {
-    return complex_from_real(complex->im->n);
+    Real* real = real_dup(complex->im->n);
+    return complex_from_real(real);
 }
 
 Complex* complex_im_u (Complex* complex)
 {
-    return complex_from_real(complex->im->u);
+    Real* real = real_dup(complex->im->u);
+    return complex_from_real(real);
 }
 
 Complex* complex_im_magnitude (Complex* complex)
 {
-    Real* l_abs;
-    Real* u_abs;
     Complex* result;
     
-    l_abs = real_abs(complex->im->l);
-    u_abs = real_abs(complex->im->u);
-    
-    result = complex_from_real(real_gt_p(l_abs, u_abs) ? l_abs : u_abs);
+    Real* l_abs = real_abs(complex->im->l);
+    Real* u_abs = real_abs(complex->im->u);
     
-    real_free(l_abs);
-    real_free(u_abs);
+    if (real_gt_p(l_abs, u_abs))
+    {
+        result = complex_from_real(l_abs);
+        real_free(u_abs);
+    }
+    else
+    {
+        result = complex_from_real(u_abs);
+        real_free(l_abs);
+    }
     
     return result;
 }
 
 Complex* complex_im_mignitude (Complex* complex)
 {
-    Real* l_abs;
-    Real* u_abs;
-    Real* zero;
     Complex* result;
     
-    l_abs = real_abs(complex->im->l);
-    u_abs = real_abs(complex->im->u);
-    zero = real_zero();
-    
-    result = complex_from_real(interval_span_zero_p(complex->im) ? zero : (real_lt_p(l_abs, u_abs) ? l_abs : u_abs));
-    
-    real_free(l_abs);
-    real_free(u_abs);
-    real_free(zero);
+    Real* l_abs = real_abs(complex->im->l);
+    Real* u_abs = real_abs(complex->im->u);
+    
+    if (interval_span_zero_p(complex->im))
+    {
+        result = complex_zero();
+        real_free(l_abs);
+        real_free(u_abs);
+    }
+    else if (real_lt_p(l_abs, u_abs))
+    {
+        result = complex_from_real(l_abs);
+        real_free(u_abs);
+    }
+    else
+    {
+        result = complex_from_real(u_abs);
+        real_free(l_abs);
+    }
     
     return result;
 }
 
 Complex* complex_im_width (Complex* complex)
 {
-    Real* width;
-    Complex* result;
-    
-    width = real_subtract(complex->im->u, complex->im->l);
-    result = complex_from_real(width);
-    
-    real_free(width);
-    
-    return result;
+    Real* real = real_subtract(complex->im->u, complex->im->l);
+    return complex_from_real(real);
 }
 
 Complex* complex_re (Complex* complex)
 {
-    return complex_new(interval_dup(complex->re), interval_zero());
+    Interval* re = interval_dup(complex->re);
+    Interval* im = interval_zero();
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_re_l (Complex* complex)
 {
-    return complex_from_real(complex->re->l);
+    Real* real = real_dup(complex->re->l);
+    return complex_from_real(real);
 }
 
 Complex* complex_re_n (Complex* complex)
 {
-    return complex_from_real(complex->re->n);
+    Real* real = real_dup(complex->re->n);
+    return complex_from_real(real);
 }
 
 Complex* complex_re_u (Complex* complex)
 {
-    return complex_from_real(complex->re->u);
+    Real* real = real_dup(complex->re->u);
+    return complex_from_real(real);
 }
 
 Complex* complex_re_magnitude (Complex* complex)
 {
-    Real* l_abs;
-    Real* u_abs;
     Complex* result;
     
-    l_abs = real_abs(complex->re->l);
-    u_abs = real_abs(complex->re->u);
+    Real* l_abs = real_abs(complex->re->l);
+    Real* u_abs = real_abs(complex->re->u);
     
-    result = complex_from_real(real_gt_p(l_abs, u_abs) ? l_abs : u_abs);
-    
-    real_free(l_abs);
-    real_free(u_abs);
+    if (real_gt_p(l_abs, u_abs))
+    {
+        result = complex_from_real(l_abs);
+        real_free(u_abs);
+    }
+    else
+    {
+        result = complex_from_real(u_abs);
+        real_free(l_abs);
+    }
     
     return result;
 }
 
 Complex* complex_re_mignitude (Complex* complex)
 {
-    Real* l_abs;
-    Real* u_abs;
-    Real* zero;
     Complex* result;
     
-    l_abs = real_abs(complex->re->l);
-    u_abs = real_abs(complex->re->u);
-    zero = real_zero();
-    
-    result = complex_from_real(interval_span_zero_p(complex->re) ? zero : (real_lt_p(l_abs, u_abs) ? l_abs : u_abs));
-    
-    real_free(l_abs);
-    real_free(u_abs);
-    real_free(zero);
+    Real* l_abs = real_abs(complex->re->l);
+    Real* u_abs = real_abs(complex->re->u);
+    
+    if (interval_span_zero_p(complex->re))
+    {
+        result = complex_zero();
+        real_free(l_abs);
+        real_free(u_abs);
+    }
+    else if (real_lt_p(l_abs, u_abs))
+    {
+        result = complex_from_real(l_abs);
+        real_free(u_abs);
+    }
+    else
+    {
+        result = complex_from_real(u_abs);
+        real_free(l_abs);
+    }
     
     return result;
 }
 
 Complex* complex_re_width (Complex* complex)
 {
-    Real* width;
-    Complex* result;
-    
-    width = real_subtract(complex->re->u, complex->re->l);
-    result = complex_from_real(width);
-    
-    real_free(width);
-    
-    return result;
+    Real* real = real_subtract(complex->re->u, complex->re->l);
+    return complex_from_real(real);
 }
 
 Complex* complex_ll (Complex* complex)
 {
-    return complex_new(interval_from_real(complex->re->l), interval_from_real(complex->im->l));
+    Interval* re = interval_from_real(complex->re->l);
+    Interval* im = interval_from_real(complex->im->l);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_lu (Complex* complex)
 {
-    return complex_new(interval_from_real(complex->re->l), interval_from_real(complex->im->u));
+    Interval* re = interval_from_real(complex->re->l);
+    Interval* im = interval_from_real(complex->im->u);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_n (Complex* complex)
 {
-    return complex_new(interval_from_real(complex->re->n), interval_from_real(complex->im->n));
+    Interval* re = interval_from_real(complex->re->n);
+    Interval* im = interval_from_real(complex->im->n);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_ul (Complex* complex)
 {
-    return complex_new(interval_from_real(complex->re->u), interval_from_real(complex->im->l));
+    Interval* re = interval_from_real(complex->re->u);
+    Interval* im = interval_from_real(complex->im->l);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_uu (Complex* complex)
 {
-    return complex_new(interval_from_real(complex->re->u), interval_from_real(complex->im->u));
+    Interval* re = interval_from_real(complex->re->u);
+    Interval* im = interval_from_real(complex->im->u);
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_magnitude (Complex* complex)
 {
-    Real* re_l_abs;
-    Real* re_u_abs;
-    Real* im_l_abs;
-    Real* im_u_abs;
-    Complex* result;
-    
-    re_l_abs = real_abs(complex->re->l);
-    re_u_abs = real_abs(complex->re->u);
-    im_l_abs = real_abs(complex->im->l);
-    im_u_abs = real_abs(complex->im->u);
-    
-    result = complex_new(interval_from_real(real_gt_p(re_l_abs, re_u_abs) ? re_l_abs : re_u_abs), interval_from_real(real_gt_p(im_l_abs, im_u_abs) ? im_l_abs : im_u_abs));
-    
-    real_free(re_l_abs);
-    real_free(re_u_abs);
-    real_free(im_l_abs);
-    real_free(im_u_abs);
-    
-    return result;
+    Interval* re;
+    Interval* im;
+    
+    Real* re_l_abs = real_abs(complex->re->l);
+    Real* re_u_abs = real_abs(complex->re->u);
+    Real* im_l_abs = real_abs(complex->im->l);
+    Real* im_u_abs = real_abs(complex->im->u);
+    
+    if (real_gt_p(re_l_abs, re_u_abs))
+    {
+        re = interval_from_real(re_l_abs);
+        real_free(re_u_abs);
+    }
+    else
+    {
+        re = interval_from_real(re_u_abs);
+        real_free(re_l_abs);
+    }
+    
+    if (real_gt_p(im_l_abs, im_u_abs))
+    {
+        im = interval_from_real(im_l_abs);
+        real_free(im_u_abs);
+    }
+    else
+    {
+        im = interval_from_real(im_u_abs);
+        real_free(im_l_abs);
+    }
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_mignitude (Complex* complex)
 {
-    Real* re_l_abs;
-    Real* re_u_abs;
-    Real* im_l_abs;
-    Real* im_u_abs;
-    Real* zero;
-    Complex* result;
-    
-    re_l_abs = real_abs(complex->re->l);
-    re_u_abs = real_abs(complex->re->u);
-    im_l_abs = real_abs(complex->im->l);
-    im_u_abs = real_abs(complex->im->u);
-    
-    zero = real_zero();
-    result = complex_new(interval_from_real(interval_span_zero_p(complex->re) ? zero : (real_lt_p(re_l_abs, re_u_abs) ? re_l_abs : re_u_abs)), interval_from_real(interval_span_zero_p(complex->im) ? zero : (real_lt_p(im_l_abs, im_u_abs) ? im_l_abs : im_u_abs)));
-    
-    real_free(re_l_abs);
-    real_free(re_u_abs);
-    real_free(im_l_abs);
-    real_free(im_u_abs);
-    real_free(zero);
-    
-    return result;
+    Interval* re;
+    Interval* im;
+    
+    Real* re_l_abs = real_abs(complex->re->l);
+    Real* re_u_abs = real_abs(complex->re->u);
+    Real* im_l_abs = real_abs(complex->im->l);
+    Real* im_u_abs = real_abs(complex->im->u);
+    
+    if (interval_span_zero_p(complex->re))
+    {
+        re = interval_zero();
+        real_free(re_l_abs);
+        real_free(re_u_abs);
+    }
+    else if (real_lt_p(re_l_abs, re_u_abs))
+    {
+        re = interval_from_real(re_l_abs);
+        real_free(re_u_abs);
+    }
+    else
+    {
+        re = interval_from_real(re_u_abs);
+        real_free(re_l_abs);
+    }
+    
+    if (interval_span_zero_p(complex->im))
+    {
+        im = interval_zero();
+        real_free(im_l_abs);
+        real_free(im_u_abs);
+    }
+    else if (real_lt_p(im_l_abs, im_u_abs))
+    {
+        im = interval_from_real(im_l_abs);
+        real_free(im_u_abs);
+    }
+    else
+    {
+        im = interval_from_real(im_u_abs);
+        real_free(im_l_abs);
+    }
+    
+    return complex_new(re, im);
 }
 
 Complex* complex_width (Complex* complex)
 {
-    Real* re_width;
-    Real* im_width;
-    Complex* result;
+    Real* re_width = real_subtract(complex->re->u, complex->re->l);
+    Real* im_width = real_subtract(complex->im->u, complex->im->l);
     
-    re_width = real_subtract(complex->re->u, complex->re->l);
-    im_width = real_subtract(complex->im->u, complex->im->l);
-    result = complex_new(interval_from_real(re_width), interval_from_real(im_width));
+    Interval* re = interval_from_real(re_width);
+    Interval* im = interval_from_real(im_width);
     
-    real_free(re_width);
-    real_free(im_width);
-    
-    return result;
+    return complex_new(re, im);
 }

data/ext/number/interval.c

@@ -75,11 +75,8 @@ int interval_span_p (Interval* interval, Real* real)
  */
 int interval_span_zero_p (Interval* interval)
 {
-    int result;
-    Real* zero;
-    
-    zero = real_zero();
-    result = interval_span_p(interval, zero);
+    Real* zero = real_zero();
+    int result = interval_span_p(interval, zero);
     
     real_free(zero);
     
@@ -91,15 +88,7 @@ int interval_span_zero_p (Interval* interval)
  */
 int interval_zero_p (Interval* interval)
 {
-    int result;
-    Real* zero;
-    
-    zero = real_zero();
-    result = real_eq_p(interval->l, zero) && real_eq_p(interval->u, zero);
-    
-    real_free(zero);
-    
-    return result;
+    return ZERO(interval->l) && ZERO(interval->u);
 }
 
 /*
@@ -119,8 +108,7 @@ int interval_degenerate_p (Interval* interval)
  */
 Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
 {
-    Interval* interval;
-    interval = malloc(sizeof(Interval));
+    Interval* interval = malloc(sizeof(Interval));
     
     if (interval == NULL)
     {
@@ -131,25 +119,25 @@ Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
     
     if (NaN(l) || NaN(n) || NaN(u))
     {
-        interval->n = real_nan();
-        interval->l = real_neg_inf();
-        interval->u = real_pos_inf();
-        
         interval->L = true;
         interval->R = true;
         
+        interval->l = real_neg_inf();
+        interval->n = real_nan();
+        interval->u = real_pos_inf();
+        
         real_free(n);
         real_free(l);
         real_free(u);
     }
     else
     {
-        interval->n = n;
-        interval->l = l;
-        interval->u = u;
-        
         interval->L = (real_eq_p(l, u) || real_eq_p(n, l) || L);
         interval->R = (real_eq_p(l, u) || real_eq_p(n, u) || R);
+        
+        interval->l = l;
+        interval->n = n;
+        interval->u = u;
     }
     
     return interval;
@@ -157,12 +145,14 @@ Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
 
 /*
  *  Returns a pointer to a newly allocated Interval containing only the given
- *  real. The given real is duplicated before being stored, and therefore must
- *  be freed separately.
+ *  real.
  */
 Interval* interval_from_real (Real* real)
 {
-    return interval_new(real_dup(real), true, real_dup(real), true, real_dup(real));
+    Real* l = real_dup(real);
+    Real* u = real_dup(real);
+    
+    return interval_new(l, true, real, true, u);
 }
 
 /*
@@ -170,7 +160,11 @@ Interval* interval_from_real (Real* real)
  */
 Interval* interval_nan ()
 {
-    return interval_new(real_neg_inf(), true, real_nan(), true, real_pos_inf());
+    Real* l = real_neg_inf();
+    Real* n = real_nan();
+    Real* u = real_pos_inf();
+    
+    return interval_new(l, true, n, true, u);
 }
 
 /*
@@ -178,7 +172,7 @@ Interval* interval_nan ()
  */
 Interval* interval_pos_inf ()
 {
-    return interval_new(real_pos_inf(), true, real_pos_inf(), true, real_pos_inf());
+    return interval_from_real(real_pos_inf());
 }
 
 /*
@@ -186,7 +180,7 @@ Interval* interval_pos_inf ()
  */
 Interval* interval_neg_inf ()
 {
-    return interval_new(real_neg_inf(), true, real_neg_inf(), true, real_neg_inf());
+    return interval_from_real(real_neg_inf());
 }
 
 /*
@@ -194,7 +188,7 @@ Interval* interval_neg_inf ()
  */
 Interval* interval_zero ()
 {
-    return interval_new(real_zero(), true, real_zero(), true, real_zero());
+    return interval_from_real(real_zero());
 }
 
 /*
@@ -202,7 +196,7 @@ Interval* interval_zero ()
  */
 Interval* interval_one ()
 {
-    return interval_new(real_one(), true, real_one(), true, real_one());
+    return interval_from_real(real_one());
 }
 
 /*
@@ -211,7 +205,11 @@ Interval* interval_one ()
  */
 Interval* interval_pi ()
 {
-    return interval_new(real_pi(ROUND_DOWN), false, real_pi(ROUND_NEAREST), false, real_pi(ROUND_UP1));
+    Real* l = real_pi(ROUND_DOWN);
+    Real* n = real_pi(ROUND_NEAREST);
+    Real* u = real_pi(ROUND_UP1);
+    
+    return interval_new(l, false, n, false, u);
 }
 
 /*
@@ -220,7 +218,11 @@ Interval* interval_pi ()
  */
 Interval* interval_e ()
 {
-    return interval_new(real_e(ROUND_DOWN), false, real_e(ROUND_NEAREST), false, real_e(ROUND_UP1));
+    Real* l = real_e(ROUND_DOWN);
+    Real* n = real_e(ROUND_NEAREST);
+    Real* u = real_e(ROUND_UP1);
+    
+    return interval_new(l, false, n, false, u);
 }
 
 /*
@@ -229,7 +231,11 @@ Interval* interval_e ()
  */
 Interval* interval_dup (Interval* interval)
 {
-    return interval_new(real_dup(interval->l), interval->L, real_dup(interval->n), interval->R, real_dup(interval->u));
+    Real* l = real_dup(interval->l);
+    Real* n = real_dup(interval->n);
+    Real* u = real_dup(interval->u);
+    
+    return interval_new(l, interval->L, n, interval->R, u);
 }
 
 /*
@@ -237,18 +243,12 @@ Interval* interval_dup (Interval* interval)
  */
 Interval* interval_add (Interval* a, Interval* b)
 {
-    int L;
-    int R;
-    Real* n;
-    Real* l;
-    Real* u;
-    
-    n = real_add(a->n, b->n);
-    l = real_add(a->l, b->l);
-    u = real_add(a->u, b->u);
+    int L = (a->L && b->L);
+    int R = (a->R && b->R);
     
-    L = (a->L && b->L);
-    R = (a->R && b->R);
+    Real* l = real_add(a->l, b->l);
+    Real* n = real_add(a->n, b->n);
+    Real* u = real_add(a->u, b->u);
     
     return interval_new(l, L, n, R, u);
 }
@@ -258,18 +258,12 @@ Interval* interval_add (Interval* a, Interval* b)
  */
 Interval* interval_subtract (Interval* a, Interval* b)
 {
-    int L;
-    int R;
-    Real* n;
-    Real* l;
-    Real* u;
+    int L = (a->L && b->R);
+    int R = (a->R && b->L);
     
-    n = real_subtract(a->n, b->n);
-    l = real_subtract(a->l, b->u);
-    u = real_subtract(a->u, b->l);
-    
-    L = (a->L && b->R);
-    R = (a->R && b->L);
+    Real* l = real_subtract(a->l, b->u);
+    Real* n = real_subtract(a->n, b->n);
+    Real* u = real_subtract(a->u, b->l);
     
     return interval_new(l, L, n, R, u);
 }
@@ -279,25 +273,19 @@ Interval* interval_subtract (Interval* a, Interval* b)
  */
 Interval* interval_multiply (Interval* a, Interval* b)
 {
-    int L;
-    int R;
-    Real* n;
-    Real* l;
-    Real* u;
-    RealBounds* bounds;
-    
-    bounds = real_bounds_new();
+    RealBounds* bounds = real_bounds_new();
+    
     real_bounds_update(bounds, real_multiply(a->l, b->l), (a->L && b->L));
     real_bounds_update(bounds, real_multiply(a->l, b->u), (a->L && b->R));
     real_bounds_update(bounds, real_multiply(a->u, b->l), (a->R && b->L));
     real_bounds_update(bounds, real_multiply(a->u, b->u), (a->R && b->R));
     
-    L = (bounds->min_closed);
-    R = (bounds->max_closed);
+    int L = (bounds->min_closed);
+    int R = (bounds->max_closed);
     
-    n = real_multiply(a->n, b->n);
-    l = real_dup(bounds->min);
-    u = real_dup(bounds->max);
+    Real* l = real_dup(bounds->min);
+    Real* n = real_multiply(a->n, b->n);
+    Real* u = real_dup(bounds->max);
     
     real_bounds_free(bounds);
     
@@ -309,14 +297,8 @@ Interval* interval_multiply (Interval* a, Interval* b)
  */
 Interval* interval_divide (Interval* a, Interval* b)
 {
-    int L;
-    int R;
-    Real* n;
-    Real* l;
-    Real* u;
-    RealBounds* bounds;
-    
-    bounds = real_bounds_new();
+    RealBounds* bounds = real_bounds_new();
+    
     real_bounds_update(bounds, real_divide(a->l, b->l, ROUND_DOWN), (a->L && b->L));
     real_bounds_update(bounds, real_divide(a->l, b->u, ROUND_DOWN), (a->L && b->R));
     real_bounds_update(bounds, real_divide(a->u, b->l, ROUND_DOWN), (a->R && b->L));
@@ -326,12 +308,12 @@ Interval* interval_divide (Interval* a, Interval* b)
     real_bounds_update(bounds, real_divide(a->u, b->l, ROUND_UP), (a->R && b->L));
     real_bounds_update(bounds, real_divide(a->u, b->u, ROUND_UP), (a->R && b->R));
     
-    L = (bounds->min_closed);
-    R = (bounds->max_closed);
+    int L = (bounds->min_closed);
+    int R = (bounds->max_closed);
     
-    n = real_divide(a->n, b->n, ROUND_NEAREST);
-    l = real_dup(bounds->min);
-    u = real_dup(bounds->max);
+    Real* l = real_dup(bounds->min);
+    Real* n = real_divide(a->n, b->n, ROUND_NEAREST);
+    Real* u = real_dup(bounds->max);
     
     real_bounds_free(bounds);
     
@@ -343,7 +325,11 @@ Interval* interval_divide (Interval* a, Interval* b)
  */
 Interval* interval_negate (Interval* interval)
 {
-    return interval_new(real_negate(interval->u), interval->R, real_negate(interval->n), interval->L, real_negate(interval->l));
+    Real* l = real_negate(interval->u);
+    Real* n = real_negate(interval->n);
+    Real* u = real_negate(interval->l);
+    
+    return interval_new(l, interval->R, n, interval->L, u);
 }
 
 /*
@@ -352,7 +338,11 @@ Interval* interval_negate (Interval* interval)
  */
 Interval* interval_round (Interval* interval)
 {
-    return interval_new(real_round(interval->l), true, real_round(interval->n), true, real_round(interval->u));
+    Real* l = real_round(interval->l);
+    Real* n = real_round(interval->n);
+    Real* u = real_round(interval->u);
+    
+    return interval_new(l, true, n, true, u);
 }
 
 /*
@@ -362,7 +352,11 @@ Interval* interval_round (Interval* interval)
  */
 Interval* interval_round_ceiling (Interval* interval)
 {
-    return interval_new(real_ceil(interval->l), true, real_ceil(interval->n), true, real_ceil(interval->u));
+    Real* l = real_ceil(interval->l);
+    Real* n = real_ceil(interval->n);
+    Real* u = real_ceil(interval->u);
+    
+    return interval_new(l, true, n, true, u);
 }
 
 /*
@@ -372,7 +366,11 @@ Interval* interval_round_ceiling (Interval* interval)
  */
 Interval* interval_round_floor (Interval* interval)
 {
-    return interval_new(real_floor(interval->l), true, real_floor(interval->n), true, real_floor(interval->u));
+    Real* l = real_floor(interval->l);
+    Real* n = real_floor(interval->n);
+    Real* u = real_floor(interval->u);
+    
+    return interval_new(l, true, n, true, u);
 }
 
 /*
@@ -382,7 +380,11 @@ Interval* interval_round_floor (Interval* interval)
  */
 Interval* interval_round_infinity (Interval* interval)
 {
-    return interval_new(real_round_infinity(interval->l), true, real_round_infinity(interval->n), true, real_round_infinity(interval->u));
+    Real* l = real_round_infinity(interval->l);
+    Real* n = real_round_infinity(interval->n);
+    Real* u = real_round_infinity(interval->u);
+    
+    return interval_new(l, true, n, true, u);
 }
 
 /*
@@ -392,5 +394,9 @@ Interval* interval_round_infinity (Interval* interval)
  */
 Interval* interval_round_origin (Interval* interval)
 {
-    return interval_new(real_round_origin(interval->l), true, real_round_origin(interval->n), true, real_round_origin(interval->u));
+    Real* l = real_round_origin(interval->l);
+    Real* n = real_round_origin(interval->n);
+    Real* u = real_round_origin(interval->u);
+    
+    return interval_new(l, true, n, true, u);
 }