number 0.9.0

data/ext/decompose.c

@@ -0,0 +1,231 @@
+#include "number.h"
+
+Complex* complex_im (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_dup(complex->im), (Interval*)interval_zero());
+}
+
+Complex* complex_im_l (Complex* complex)
+{
+    return (Complex*)complex_from_real(complex->im->l);
+}
+
+Complex* complex_im_n (Complex* complex)
+{
+    return (Complex*)complex_from_real(complex->im->n);
+}
+
+Complex* complex_im_u (Complex* complex)
+{
+    return (Complex*)complex_from_real(complex->im->u);
+}
+
+Complex* complex_im_magnitude (Complex* complex)
+{
+    Real* l_abs;
+    Real* u_abs;
+    Complex* result;
+    
+    l_abs = (Real*)real_abs(complex->im->l);
+    u_abs = (Real*)real_abs(complex->im->u);
+    
+    result = (Complex*)complex_from_real(real_gt_p(l_abs, u_abs) ? l_abs : u_abs);
+    
+    real_free(l_abs);
+    real_free(u_abs);
+    
+    return result;
+}
+
+Complex* complex_im_mignitude (Complex* complex)
+{
+    Real* l_abs;
+    Real* u_abs;
+    Real* zero;
+    Complex* result;
+    
+    l_abs = (Real*)real_abs(complex->im->l);
+    u_abs = (Real*)real_abs(complex->im->u);
+    zero = (Real*)real_zero();
+    
+    result = (Complex*)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);
+    
+    return result;
+}
+
+Complex* complex_im_width (Complex* complex)
+{
+    Real* width;
+    Complex* result;
+    
+    width = (Real*)real_subtract(complex->im->u, complex->im->l);
+    result = (Complex*)complex_from_real(width);
+    
+    real_free(width);
+    
+    return result;
+}
+
+Complex* complex_re (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_dup(complex->re), (Interval*)interval_zero());
+}
+
+Complex* complex_re_l (Complex* complex)
+{
+    return (Complex*)complex_from_real(complex->re->l);
+}
+
+Complex* complex_re_n (Complex* complex)
+{
+    return (Complex*)complex_from_real(complex->re->n);
+}
+
+Complex* complex_re_u (Complex* complex)
+{
+    return (Complex*)complex_from_real(complex->re->u);
+}
+
+Complex* complex_re_magnitude (Complex* complex)
+{
+    Real* l_abs;
+    Real* u_abs;
+    Complex* result;
+    
+    l_abs = (Real*)real_abs(complex->re->l);
+    u_abs = (Real*)real_abs(complex->re->u);
+    
+    result = (Complex*)complex_from_real(real_gt_p(l_abs, u_abs) ? l_abs : u_abs);
+    
+    real_free(l_abs);
+    real_free(u_abs);
+    
+    return result;
+}
+
+Complex* complex_re_mignitude (Complex* complex)
+{
+    Real* l_abs;
+    Real* u_abs;
+    Real* zero;
+    Complex* result;
+    
+    l_abs = (Real*)real_abs(complex->re->l);
+    u_abs = (Real*)real_abs(complex->re->u);
+    zero = (Real*)real_zero();
+    
+    result = (Complex*)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);
+    
+    return result;
+}
+
+Complex* complex_re_width (Complex* complex)
+{
+    Real* width;
+    Complex* result;
+    
+    width = (Real*)real_subtract(complex->re->u, complex->re->l);
+    result = (Complex*)complex_from_real(width);
+    
+    real_free(width);
+    
+    return result;
+}
+
+Complex* complex_ll (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_from_real(complex->re->l), (Interval*)interval_from_real(complex->im->l));
+}
+
+Complex* complex_lu (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_from_real(complex->re->l), (Interval*)interval_from_real(complex->im->u));
+}
+
+Complex* complex_n (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_from_real(complex->re->n), (Interval*)interval_from_real(complex->im->n));
+}
+
+Complex* complex_ul (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_from_real(complex->re->u), (Interval*)interval_from_real(complex->im->l));
+}
+
+Complex* complex_uu (Complex* complex)
+{
+    return (Complex*)complex_new((Interval*)interval_from_real(complex->re->u), (Interval*)interval_from_real(complex->im->u));
+}
+
+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*)real_abs(complex->re->l);
+    re_u_abs = (Real*)real_abs(complex->re->u);
+    im_l_abs = (Real*)real_abs(complex->im->l);
+    im_u_abs = (Real*)real_abs(complex->im->u);
+    
+    result = (Complex*)complex_new((Interval*)interval_from_real(real_gt_p(re_l_abs, re_u_abs) ? re_l_abs : re_u_abs), (Interval*)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;
+}
+
+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*)real_abs(complex->re->l);
+    re_u_abs = (Real*)real_abs(complex->re->u);
+    im_l_abs = (Real*)real_abs(complex->im->l);
+    im_u_abs = (Real*)real_abs(complex->im->u);
+    
+    zero = (Real*)real_zero();
+    result = (Complex*)complex_new((Interval*)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*)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;
+}
+
+Complex* complex_width (Complex* complex)
+{
+    Real* re_width;
+    Real* im_width;
+    Complex* result;
+    
+    re_width = (Real*)real_subtract(complex->re->u, complex->re->l);
+    im_width = (Real*)real_subtract(complex->im->u, complex->im->l);
+    result = (Complex*)complex_new((Interval*)interval_from_real(re_width), (Interval*)interval_from_real(im_width));
+    
+    real_free(re_width);
+    real_free(im_width);
+    
+    return result;
+}

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+#encoding: UTF-8
+require 'mkmf'
+
+have_library('gmp')
+have_library('mpfr')
+have_library('mpc')
+create_makefile('number')

data/ext/interval.c

@@ -0,0 +1,394 @@
+#include "number.h"
+
+/*
+ *  Frees the memory block pointed to by interval.
+ */
+void interval_free (Interval* interval)
+{
+    if (interval)
+    {
+        if (interval->n)
+        {
+            real_free(interval->n);
+        }
+        
+        if (interval->l)
+        {
+            real_free(interval->l);
+        }
+        
+        if (interval->u)
+        {
+            real_free(interval->u);
+        }
+        
+        free(interval);
+        interval = NULL;
+    }
+}
+
+/*
+ *  Returns the maximum size of the string representation of interval as a long.
+ */
+long interval_strlen (Interval* interval)
+{
+    return real_strlen(interval->l) + real_strlen(interval->n) + real_strlen(interval->u) + 10;
+}
+
+/*
+ *  Puts a string representation of interval into the string pointed to by buf.
+ *  
+ *    interval: {1:1 < 2:1 < 3:1} => str: "{1:1 < 2:1 < 3:1}"
+ *    interval: {0:1 ≤ 0:1 ≤ 0:1} => str: "{0:1 ≤ 0:1 ≤ 0:1}"
+ */
+void interval_print(char* buf, Interval* interval)
+{
+    char n_str[real_strlen(interval->n)];
+    char l_str[real_strlen(interval->l)];
+    char u_str[real_strlen(interval->u)];
+    
+    if (interval_degenerate_p(interval))
+    {
+        real_print(n_str, interval->n);
+        sprintf(buf, "%s", n_str);
+    }
+    else
+    {
+        real_print(n_str, interval->n);
+        real_print(l_str, interval->l);
+        real_print(u_str, interval->u);
+        
+        sprintf(buf, "[%s %s (%s) %s %s]", l_str, interval->L ? "≤" : "<", n_str, interval->R ? "≤" : "<", u_str);
+    }
+}
+
+/*
+ *  Returns 1 if interval contains real, 0 otherwise.
+ */
+int interval_span_p (Interval* interval, Real* real)
+{
+    return !(real_gt_p(interval->l, real) || real_lt_p(interval->u, real) || (real_eq_p(interval->l, real) && !interval->L) || (real_eq_p(interval->u, real) && !interval->R));
+}
+
+/*
+ *  Returns 1 if interval contains zero, 0 otherwise.
+ */
+int interval_span_zero_p (Interval* interval)
+{
+    int result;
+    Real* zero;
+    
+    zero = (Real*)real_zero();
+    result = interval_span_p(interval, zero);
+    
+    real_free(zero);
+    
+    return result;
+}
+
+/*
+ *  Returns 1 if interval contains only zero, 0 otherwise.
+ */
+int interval_zero_p (Interval* interval)
+{
+    int result;
+    Real* zero;
+    
+    zero = (Real*)real_zero();
+    result = real_eq_p(interval->l, zero) && real_eq_p(interval->u, zero);
+    
+    real_free(zero);
+    
+    return result;
+}
+
+/*
+ *  Returns 1 if interval contains exactly one real number, 0 otherwise.
+ */
+int interval_degenerate_p (Interval* interval)
+{
+    return real_eq_p(interval->l, interval->u);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval with the given value. The
+ *  given reals will be referenced by the new interval and must be freed only
+ *  when this interval is freed.
+ *  
+ *    l: (1:1), L: 0, n: (2:1), R: 1, u: (3:1) => interval: {1:1 < 2:1 ≤ 3:1}
+ */
+Interval* interval_new (Real* l, int L, Real* n, int R, Real* u)
+{
+    Interval* interval;
+    interval = (Interval*)malloc(sizeof(Interval));
+    
+    if (interval == NULL)
+    {
+        return NULL;
+    }
+    
+    memset(interval, 0, sizeof(Interval));
+    
+    if (NaN(l) || NaN(n) || NaN(u))
+    {
+        interval->n = (Real*)real_nan();
+        interval->l = (Real*)real_neg_inf();
+        interval->u = (Real*)real_pos_inf();
+        
+        interval->L = true;
+        interval->R = true;
+        
+        real_free(n);
+        real_free(l);
+        real_free(u);
+    }
+    else
+    {
+        interval->n = (Real*)n;
+        interval->l = (Real*)l;
+        interval->u = (Real*)u;
+        
+        interval->L = real_eq_p(interval->l, interval->u) || real_eq_p(interval->n, interval->l) || L;
+        interval->R = real_eq_p(interval->l, interval->u) || real_eq_p(interval->n, interval->u) || R;
+    }
+    
+    return interval;
+}
+
+/*
+ *  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.
+ */
+Interval* interval_from_real (Real* real)
+{
+    return interval_new((Real*)real_dup(real), true, (Real*)real_dup(real), true, (Real*)real_dup(real));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing a NaN value.
+ */
+Interval* interval_nan ()
+{
+    return interval_new((Real*)real_neg_inf(), true, (Real*)real_nan(), true, (Real*)real_pos_inf());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing only +∞.
+ */
+Interval* interval_pos_inf ()
+{
+    return interval_new((Real*)real_pos_inf(), true, (Real*)real_pos_inf(), true, (Real*)real_pos_inf());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing only -∞.
+ */
+Interval* interval_neg_inf ()
+{
+    return interval_new((Real*)real_neg_inf(), true, (Real*)real_neg_inf(), true, (Real*)real_neg_inf());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing only 0.
+ */
+Interval* interval_zero ()
+{
+    return interval_new((Real*)real_zero(), true, (Real*)real_zero(), true, (Real*)real_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing only 1.
+ */
+Interval* interval_one ()
+{
+    return interval_new((Real*)real_one(), true, (Real*)real_one(), true, (Real*)real_one());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing π, accurate to
+ *  digs digits.
+ */
+Interval* interval_pi ()
+{
+    return (Interval*)interval_new((Real*)real_pi(ROUND_DOWN), false, (Real*)real_pi(ROUND_NEAREST), false, (Real*)real_pi(ROUND_UP1));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing e, accurate to
+ *  digs digits.
+ */
+Interval* interval_e ()
+{
+    return (Interval*)interval_new((Real*)real_e(ROUND_DOWN), false, (Real*)real_e(ROUND_NEAREST), false, (Real*)real_e(ROUND_UP1));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval with the same value as the
+ *  given interval.
+ */
+Interval* interval_dup (Interval* interval)
+{
+    return interval_new((Real*)real_dup(interval->l), interval->L, (Real*)real_dup(interval->n), interval->R, (Real*)real_dup(interval->u));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing a + b.
+ */
+Interval* interval_add (Interval* a, Interval* b)
+{
+    int L;
+    int R;
+    Real* n;
+    Real* l;
+    Real* u;
+    
+    n = (Real*)real_add(a->n, b->n);
+    l = (Real*)real_add(a->l, b->l);
+    u = (Real*)real_add(a->u, b->u);
+    
+    L = a->L && b->L;
+    R = a->R && b->R;
+    
+    return interval_new(l, L, n, R, u);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing a - b.
+ */
+Interval* interval_subtract (Interval* a, Interval* b)
+{
+    int L;
+    int R;
+    Real* n;
+    Real* l;
+    Real* u;
+    
+    n = (Real*)real_subtract(a->n, b->n);
+    l = (Real*)real_subtract(a->l, b->u);
+    u = (Real*)real_subtract(a->u, b->l);
+    
+    L = a->L && b->R;
+    R = a->R && b->L;
+    
+    return interval_new(l, L, n, R, u);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing a * b.
+ */
+Interval* interval_multiply (Interval* a, Interval* b)
+{
+    int L;
+    int R;
+    Real* n;
+    Real* l;
+    Real* u;
+    RealBounds* bounds;
+    Interval* interval;
+    
+    bounds = (RealBounds*)real_bounds_new();
+    real_bounds_update(bounds, (Real*)real_multiply(a->l, b->l), a->L && b->L);
+    real_bounds_update(bounds, (Real*)real_multiply(a->l, b->u), a->L && b->R);
+    real_bounds_update(bounds, (Real*)real_multiply(a->u, b->l), a->R && b->L);
+    real_bounds_update(bounds, (Real*)real_multiply(a->u, b->u), a->R && b->R);
+    
+    L = bounds->min_closed;
+    R = bounds->max_closed;
+    
+    n = (Real*)real_multiply(a->n, b->n);
+    l = (Real*)real_dup(bounds->min);
+    u = (Real*)real_dup(bounds->max);
+    
+    real_bounds_free(bounds);
+    
+    return interval_new(l, L, n, R, u);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing a / b.
+ */
+Interval* interval_divide (Interval* a, Interval* b)
+{
+    int L;
+    int R;
+    Real* n;
+    Real* l;
+    Real* u;
+    RealBounds* bounds;
+    Interval* interval;
+    
+    bounds = (RealBounds*)real_bounds_new();
+    real_bounds_update(bounds, (Real*)real_divide(a->l, b->l, ROUND_NEAREST), a->L && b->L);
+    real_bounds_update(bounds, (Real*)real_divide(a->l, b->u, ROUND_NEAREST), a->L && b->R);
+    real_bounds_update(bounds, (Real*)real_divide(a->u, b->l, ROUND_NEAREST), a->R && b->L);
+    real_bounds_update(bounds, (Real*)real_divide(a->u, b->u, ROUND_NEAREST), a->R && b->R);
+    
+    L = bounds->min_closed;
+    R = bounds->max_closed;
+    
+    n = (Real*)real_divide(a->n, b->n);
+    l = (Real*)real_dup(bounds->min);
+    u = (Real*)real_dup(bounds->max);
+    
+    real_bounds_free(bounds);
+    
+    return interval_new(l, L, n, R, u);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing -interval.
+ */
+Interval* interval_negate (Interval* interval)
+{
+    return interval_new((Real*)real_negate(interval->u), interval->R, (Real*)real_negate(interval->n), interval->L, (Real*)real_negate(interval->l));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing the elements of
+ *  interval rounded to the nearest integer values.
+ */
+Interval* interval_round (Interval* interval)
+{
+    return interval_new((Real*)real_round(interval->l), true, (Real*)real_round(interval->n), true, (Real*)real_round(interval->u));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing the elements of
+ *  interval rounded to the next closest integer values in the direction of
+ *  positive infinity.
+ */
+Interval* interval_round_ceiling (Interval* interval)
+{
+    return interval_new((Real*)real_ceil(interval->l), true, (Real*)real_ceil(interval->n), true, (Real*)real_ceil(interval->u));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing the elements of
+ *  interval rounded to the next closest integer values in the direction of
+ *  negative infinity.
+ */
+Interval* interval_round_floor (Interval* interval)
+{
+    return interval_new((Real*)real_floor(interval->l), true, (Real*)real_floor(interval->n), true, (Real*)real_floor(interval->u));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing the elements of
+ *  interval rounded to the next closest integer values in the direction away
+ *  from the origin.
+ */
+Interval* interval_round_infinity (Interval* interval)
+{
+    return interval_new((Real*)real_round_infinity(interval->l), true, (Real*)real_round_infinity(interval->n), true, (Real*)real_round_infinity(interval->u));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Interval containing the elements of
+ *  interval rounded to the next closest integer values in the direction of the
+ *  origin.
+ */
+Interval* interval_round_origin (Interval* interval)
+{
+    return interval_new((Real*)real_round_origin(interval->l), true, (Real*)real_round_origin(interval->n), true, (Real*)real_round_origin(interval->u));
+}