number 0.9.0

data/ext/complex.c

@@ -0,0 +1,674 @@
+#include "number.h"
+
+/*
+ *  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)
+{
+    char buf[10000];
+    char tmp_re_buf[10000];
+    char tmp_im_buf[10000];
+    char re_buf[10000];
+    char im_buf[10000];
+    
+    if (REAL(re))
+    {
+        gmp_sprintf(tmp_re_buf, "%+Zd", re->num);
+        sprintf(re_buf, "%c0.%se%ld", *tmp_re_buf, tmp_re_buf + 1, re->exp);
+    }
+    else
+    {
+        sprintf(re_buf, "%s", NaN(re) ? "@nan@" : POS_INF(re) ? "@inf@" : "-@inf@");
+    }
+    
+    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);
+    }
+    else
+    {
+        sprintf(im_buf, "%s", NaN(im) ? "@nan@" : POS_INF(im) ? "@inf@" : "-@inf@");
+    }
+    
+    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)
+{
+    char sign;
+    char buf[10000];
+    char real_buf[10000];
+    
+    if (REAL(real))
+    {
+        gmp_sprintf(real_buf, "%+Zd", real->num);
+        sprintf(buf, "%c0.%se%ld", *real_buf, real_buf + 1, real->exp);
+    }
+    else
+    {
+        sprintf(buf, "%s", NaN(real) ? "@nan@" : POS_INF(real) ? "@inf@" : "-@inf@");
+    }
+    
+    mpfr_init2(num, PREC);
+    mpfr_set_str(num, buf, 10, MPFR_RNDN);
+}
+
+/*
+ *  Frees the memory block pointed to by complex.
+ */
+void complex_free (Complex* complex)
+{
+    if (complex)
+    {
+        if (complex->re)
+        {
+            interval_free(complex->re);
+        }
+        
+        if (complex->im)
+        {
+            interval_free(complex->im);
+        }
+        
+        free(complex);
+        complex = NULL;
+    }
+}
+
+/*
+ *  Returns the maximum size of the string representation of complex as a long.
+ */
+long complex_strlen (Complex* complex)
+{
+    return interval_strlen(complex->re) + interval_strlen(complex->im) + 10;
+}
+
+/*
+ *  Puts a string representation of complex into the string pointed to by buf.
+ *  
+ *    complex: ({1:1 < 2:1 < 3:1},{0:1 ≤ 0:1 ≤ 0:1}) => str: "{1:1 < 2:1 < 3:1}, {0:1 ≤ 0:1 ≤ 0:1}i"
+ */
+void complex_print (char* buf, Complex* complex)
+{
+    char rbuf[interval_strlen(complex->re)];
+    char ibuf[interval_strlen(complex->im)];
+    
+    if (interval_zero_p(complex->im))
+    {
+        interval_print(rbuf, complex->re);
+        sprintf(buf, "%s", rbuf);
+    }
+    else
+    {
+        interval_print(rbuf, complex->re);
+        interval_print(ibuf, complex->im);
+        
+        sprintf(buf, "%s+%si", rbuf, ibuf);
+    }
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex with the given value. The
+ *  given intervals will be referenced by the new complex and must be freed only
+ *  when this complex is freed.
+ *  
+ *    re: {1:1 < 2:1 < 3:1}, im: {0:1 ≤ 0:1 ≤ 0:1} => complex: {1:1 < 2:1 < 3:1}, {0:1 ≤ 0:1 ≤ 0:1}
+ */
+Complex* complex_new (Interval* re, Interval* im)
+{
+    Complex* complex;
+    complex = (Complex*)malloc(sizeof(Complex));
+    
+    if (complex == NULL)
+    {
+        return NULL;
+    }
+    
+    memset(complex, 0, sizeof(Complex));
+    complex->re = (Interval*)re;
+    complex->im = (Interval*)im;
+    
+    return complex;
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex with the given real as its
+ *  real part and 0 as its imaginary part. The given real is duplicated before
+ *  being stored, and therefore must be freed separately.
+ */
+Complex* complex_from_real (Real* real)
+{
+    return complex_new((Interval*)interval_from_real(real), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex with the integer represented
+ *  by str as its real part.
+ */
+Complex* complex_from_int_str (char* buf)
+{
+    Real* real;
+    Complex* result;
+    
+    real = (Real*)real_from_str(buf, strlen(buf) - (*buf == '-'));
+    result = (Complex*)complex_from_real(real);
+    
+    real_free(real);
+    
+    return result;
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex with the float represented by
+ *  str as its real part.
+ */
+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);
+    
+    real = (Real*)real_from_mpfr(num, ROUND_NEAREST);
+    result = (Complex*)complex_from_real(real);
+    
+    mpfr_clear(num);
+    real_free(real);
+    
+    return result;
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing a NaN value.
+ */
+Complex* complex_nan ()
+{
+    return complex_new((Interval*)interval_nan(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing only +∞.
+ */
+Complex* complex_pos_inf ()
+{
+    return complex_new((Interval*)interval_pos_inf(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing only -∞.
+ */
+Complex* complex_neg_inf ()
+{
+    return complex_new((Interval*)interval_neg_inf(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing only 0.
+ */
+Complex* complex_zero ()
+{
+    return complex_new((Interval*)interval_zero(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing only 1.
+ */
+Complex* complex_one ()
+{
+    return complex_new((Interval*)interval_one(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing π, accurate to
+ *  digs digits.
+ */
+Complex* complex_pi ()
+{
+    return complex_new((Interval*)interval_pi(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing e, accurate to
+ *  digs digits.
+ */
+Complex* complex_e ()
+{
+    return complex_new((Interval*)interval_e(), (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing only i.
+ */
+Complex* complex_i ()
+{
+    return complex_new((Interval*)interval_zero(), (Interval*)interval_one());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex with the same value as the
+ *  given complex.
+ */
+Complex* complex_dup (Complex* complex)
+{
+    return complex_new((Interval*)interval_dup(complex->re), (Interval*)interval_dup(complex->im));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing a + b.
+ */
+Complex* complex_add (Complex* a, Complex* b)
+{
+    Interval* re;
+    Interval* im;
+    
+    re = (Interval*)interval_add(a->re, b->re);
+    im = (Interval*)interval_add(a->im, b->im);
+    
+    return complex_new(re, im);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing a - b.
+ */
+Complex* complex_subtract (Complex* a, Complex* b)
+{
+    Interval* re;
+    Interval* im;
+    
+    re = (Interval*)interval_subtract(a->re, b->re);
+    im = (Interval*)interval_subtract(a->im, b->im);
+    
+    return complex_new(re, im);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing a * b.
+ */
+Complex* complex_multiply (Complex* a, Complex* b)
+{
+    Interval* re_re;
+    Interval* re_im;
+    Interval* im_re;
+    Interval* im_im;
+    Interval* re;
+    Interval* im;
+    
+    re_re = (Interval*)interval_multiply(a->re, b->re);
+    re_im = (Interval*)interval_multiply(a->re, b->im);
+    im_re = (Interval*)interval_multiply(a->im, b->re);
+    im_im = (Interval*)interval_multiply(a->im, b->im);
+    
+    re = (Interval*)interval_subtract(re_re, im_im);
+    im = (Interval*)interval_add(re_im, im_re);
+    
+    interval_free(re_re);
+    interval_free(re_im);
+    interval_free(im_re);
+    interval_free(im_im);
+    
+    return (Complex*)complex_new(re, im);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing a / 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;
+    Interval* numerator_re;
+    Interval* numerator_im;
+    Interval* re_re;
+    Interval* re_im;
+    Interval* im_re;
+    Interval* im_im;
+    Interval* re;
+    Interval* im;
+    
+    denominator_re = (Interval*)interval_multiply(b->re, b->re);
+    denominator_im = (Interval*)interval_multiply(b->im, b->im);
+    denominator = (Interval*)interval_add(denominator_re, denominator_im);
+    
+    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);
+        
+        mpc_div(num_quotient, num_numerator, num_denominator, MPC_RNDNN);
+        
+        mpc_real(num_re, num_quotient, MPFR_RNDN);
+        mpc_imag(num_im, num_quotient, MPFR_RNDN);
+        
+        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_clear(num_numerator);
+        mpc_clear(num_denominator);
+        mpc_clear(num_quotient);
+        mpfr_clear(num_re);
+        mpfr_clear(num_im);
+    }
+    else
+    {
+        re_re = (Interval*)interval_multiply(a->re, b->re);
+        re_im = (Interval*)interval_multiply(a->re, b->im);
+        im_re = (Interval*)interval_multiply(a->im, b->re);
+        im_im = (Interval*)interval_multiply(a->im, b->im);
+        
+        numerator_re = (Interval*)interval_add(re_re, im_im);
+        numerator_im = (Interval*)interval_subtract(im_re, re_im);
+        
+        re = (Interval*)interval_divide(numerator_re, denominator);
+        im = (Interval*)interval_divide(numerator_im, denominator);
+        
+        interval_free(re_re);
+        interval_free(re_im);
+        interval_free(im_re);
+        interval_free(im_im);
+        interval_free(numerator_re);
+        interval_free(numerator_im);
+    }
+    
+    interval_free(denominator_re);
+    interval_free(denominator_im);
+    interval_free(denominator);
+    
+    return (Complex*)complex_new(re, im);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing a % b.
+ */
+Complex* complex_modulo (Complex* a, Complex* b)
+{
+    Interval* re;
+    Interval* im;
+    
+    re = (Interval*)interval_zero();
+    im = (Interval*)interval_zero();
+    
+    return (Complex*)complex_new(re, im);
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing the absolute value
+ *  of complex.
+ */
+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;
+    
+    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);
+    
+    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);
+    
+    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);
+        
+        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);
+        
+        real_free(re_l_abs);
+        real_free(re_u_abs);
+        
+        mpfr_clear(num_re_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);
+        
+        real_free(im_l_abs);
+        real_free(im_u_abs);
+        
+        mpfr_clear(num_im_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);
+    }
+    
+    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));
+    
+    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());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing the area of the
+ *  region in the complex plane enclosed by complex.
+ */
+Complex* complex_area (Complex* complex)
+{
+    Real* re_width;
+    Real* im_width;
+    Real* area;
+    Complex* result;
+    
+    re_width = (Real*)real_subtract(complex->re->u, complex->re->l);
+    im_width = (Real*)real_subtract(complex->im->u, complex->im->l);
+    area = (Real*)real_multiply(re_width, im_width);
+    result = (Complex*)complex_from_real(area);
+    
+    real_free(re_width);
+    real_free(im_width);
+    real_free(area);
+    
+    return result;
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing the length of the
+ *  diagonal of the region in the complex plane enclosed by complex.
+ */
+Complex* complex_diagonal (Complex* complex)
+{
+    mpfr_t num_diag;
+    Real* re_width;
+    Real* im_width;
+    Real* re_width2;
+    Real* im_width2;
+    Real* diag2;
+    Interval* re;
+    Complex* result;
+    
+    re_width = (Real*)real_subtract(complex->re->u, complex->re->l);
+    im_width = (Real*)real_subtract(complex->im->u, complex->im->l);
+    
+    re_width2 = (Real*)real_multiply(re_width, re_width);
+    im_width2 = (Real*)real_multiply(im_width, im_width);
+    
+    diag2 = (Real*)real_add(re_width2, im_width2);
+    
+    mpfr_init_set_r(num_diag, diag2);
+    mpfr_sqrt(num_diag, num_diag, 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));
+    
+    real_free(re_width);
+    real_free(im_width);
+    real_free(re_width2);
+    real_free(im_width2);
+    real_free(diag2);
+    
+    mpfr_clear(num_diag);
+    
+    return (Complex*)complex_new(re, (Interval*)interval_zero());
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing the conjugate of
+ *  complex.
+ */
+Complex* complex_conjugate (Complex* complex)
+{
+    return complex_new((Interval*)interval_dup(complex->re), (Interval*)interval_negate(complex->im));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing -complex.
+ */
+Complex* complex_negate (Complex* complex)
+{
+    return complex_new((Interval*)interval_negate(complex->re), (Interval*)interval_negate(complex->im));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing the reflection of
+ *  complex over the line re == im.
+ */
+Complex* complex_reflect (Complex* complex)
+{
+    return complex_new((Interval*)interval_dup(complex->im), (Interval*)interval_dup(complex->re));
+}
+
+/*
+ *  Returns a pointer to a newly allocated Complex containing √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;
+    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);
+    
+    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);
+    
+    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);
+        
+        bounds_update(bounds, num_re_sqrt, complex->re->L);
+        
+        real_free(zero);
+        mpc_clear(num_re_sqrt);
+    }
+    
+    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));
+    
+    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);
+}