rubysl-bigdecimal 1.0.0 → 2.0.2

data/ext/rubysl/bigdecimal/bigdecimal.h

@@ -1,25 +1,76 @@
 /*
  *
- * Ruby BigDecimal(Variable decimal precision) extension library. 
+ * Ruby BigDecimal(Variable decimal precision) extension library.
  *
- * Copyright(C) 2002 by Shigeo Kobayashi(shigeo@tinyforest.gr.jp) 
+ * Copyright(C) 2002 by Shigeo Kobayashi(shigeo@tinyforest.gr.jp)
  *
- * You may distribute under the terms of either the GNU General Public 
- * License or the Artistic License, as specified in the README file 
- * of this BigDecimal distribution. 
+ * You may distribute under the terms of either the GNU General Public
+ * License or the Artistic License, as specified in the README file
+ * of this BigDecimal distribution.
  *
  * NOTES:
  *   2003-03-28 V1.0 checked in.
  *
  */
 
-#ifndef  ____BIG_DECIMAL__H____
-#define  ____BIG_DECIMAL__H____
+#ifndef  RUBY_BIG_DECIMAL_H
+#define  RUBY_BIG_DECIMAL_H 1
+
+// Use RSTRING_PTR without caching on Rubinius
+#define RSTRING_NOT_MODIFIED 1
+
+#include "ruby/ruby.h"
+#include <float.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
+#ifndef HAVE_LABS
+static inline long
+labs(long const x)
+{
+    if (x < 0) return -x;
+    return x;
+}
+#endif
+
+#ifndef HAVE_LLABS
+static inline LONG_LONG
+llabs(LONG_LONG const x)
+{
+    if (x < 0) return -x;
+    return x;
+}
+#endif
+
+#ifdef vabs
+# undef vabs
+#endif
+#if SIZEOF_VALUE <= SIZEOF_INT
+# define vabs abs
+#elif SIZEOF_VALUE <= SIZEOF_LONG
+# define vabs labs
+#elif SIZEOF_VALUE <= SIZEOF_LONG_LONG
+# define vabs llabs
+#endif
+
+extern VALUE rb_cBigDecimal;
+
+#if SIZEOF_BDIGITS >= 8
+# define RMPD_COMPONENT_FIGURES 19
+# define RMPD_BASE ((BDIGIT)10000000000000000000U)
+#elif SIZEOF_BDIGITS >= 4
+# define RMPD_COMPONENT_FIGURES 9
+# define RMPD_BASE ((BDIGIT)1000000000U)
+#elif SIZEOF_BDIGITS >= 2
+# define RMPD_COMPONENT_FIGURES 4
+# define RMPD_BASE ((BDIGIT)10000U)
+#else
+# define RMPD_COMPONENT_FIGURES 2
+# define RMPD_BASE ((BDIGIT)100U)
+#endif
+
 /*
  *  NaN & Infinity
  */
@@ -29,15 +80,10 @@ extern "C" {
 #define SZ_NINF "-Infinity"
 
 /*
- *   #define VP_EXPORT other than static to let VP_ routines 
+ *   #define VP_EXPORT other than static to let VP_ routines
  *   be called from outside of this module.
  */
-#define VP_EXPORT static 
-
-#define U_LONG unsigned long
-#define S_LONG long
-#define U_INT  unsigned int
-#define S_INT  int
+#define VP_EXPORT static
 
 /* Exception codes */
 #define VP_EXCEPTION_ALL        ((unsigned short)0x00FF)
@@ -45,12 +91,14 @@ extern "C" {
 #define VP_EXCEPTION_NaN        ((unsigned short)0x0002)
 #define VP_EXCEPTION_UNDERFLOW  ((unsigned short)0x0004)
 #define VP_EXCEPTION_OVERFLOW   ((unsigned short)0x0001) /* 0x0008) */
-#define VP_EXCEPTION_ZERODIVIDE ((unsigned short)0x0001) /* 0x0010) */
+#define VP_EXCEPTION_ZERODIVIDE ((unsigned short)0x0010)
 
 /* Following 2 exceptions cann't controlled by user */
 #define VP_EXCEPTION_OP         ((unsigned short)0x0020)
 #define VP_EXCEPTION_MEMORY     ((unsigned short)0x0040)
 
+#define RMPD_EXCEPTION_MODE_DEFAULT 0U
+
 /* Computation mode */
 #define VP_ROUND_MODE            ((unsigned short)0x0100)
 #define VP_ROUND_UP         1
@@ -61,6 +109,8 @@ extern "C" {
 #define VP_ROUND_FLOOR      6
 #define VP_ROUND_HALF_EVEN  7
 
+#define RMPD_ROUNDING_MODE_DEFAULT  VP_ROUND_HALF_UP
+
 #define VP_SIGN_NaN                0 /* NaN                      */
 #define VP_SIGN_POSITIVE_ZERO      1 /* Positive zero            */
 #define VP_SIGN_NEGATIVE_ZERO     -1 /* Negative zero            */
@@ -75,13 +125,13 @@ extern "C" {
  */
 typedef struct {
     VALUE  obj;     /* Back pointer(VALUE) for Ruby object.     */
-    U_LONG MaxPrec; /* Maximum precision size                   */
+    size_t MaxPrec; /* Maximum precision size                   */
                     /* This is the actual size of pfrac[]       */
                     /*(frac[0] to frac[MaxPrec] are available). */
-    U_LONG Prec;    /* Current precision size.                  */
+    size_t Prec;    /* Current precision size.                  */
                     /* This indicates how much the.             */
                     /* the array frac[] is actually used.       */
-    S_INT  exponent;/* Exponent part.                           */
+    SIGNED_VALUE exponent; /* Exponent part.                    */
     short  sign;    /* Attributes of the value.                 */
                     /*
                      *        ==0 : NaN
@@ -93,23 +143,30 @@ typedef struct {
                      *         -3 : Negative infinite number
                      */
     short  flag;    /* Not used in vp_routines,space for user.  */
-    U_LONG frac[1]; /* Pointer to array of fraction part.       */
+    BDIGIT frac[1]; /* Pointer to array of fraction part.       */
 } Real;
 
-/*  
+/*
  *  ------------------
  *   EXPORTables.
  *  ------------------
  */
 
 VP_EXPORT  Real *
-VpNewRbClass(U_LONG mx,char *str,VALUE klass);
+VpNewRbClass(size_t mx, char const *str, VALUE klass);
 
-VP_EXPORT  Real *VpCreateRbObject(U_LONG mx,const char *str);
+VP_EXPORT  Real *VpCreateRbObject(size_t mx,const char *str);
 
-VP_EXPORT U_LONG VpBaseFig(void);
-VP_EXPORT U_LONG VpDblFig(void);
-VP_EXPORT U_LONG VpBaseVal(void);
+static inline BDIGIT
+rmpd_base_value(void) { return RMPD_BASE; }
+static inline size_t
+rmpd_component_figures(void) { return RMPD_COMPONENT_FIGURES; }
+static inline size_t
+rmpd_double_figures(void) { return 1+DBL_DIG; }
+
+#define VpBaseFig() rmpd_component_figures()
+#define VpDblFig() rmpd_double_figures()
+#define VpBaseVal() rmpd_base_value()
 
 /* Zero,Inf,NaN (isinf(),isnan() used to check) */
 VP_EXPORT double VpGetDoubleNaN(void);
@@ -118,50 +175,50 @@ VP_EXPORT double VpGetDoubleNegInf(void);
 VP_EXPORT double VpGetDoubleNegZero(void);
 
 /* These 2 functions added at v1.1.7 */
-VP_EXPORT U_LONG VpGetPrecLimit(void);
-VP_EXPORT U_LONG VpSetPrecLimit(U_LONG n);
+VP_EXPORT size_t VpGetPrecLimit(void);
+VP_EXPORT size_t VpSetPrecLimit(size_t n);
 
 /* Round mode */
-VP_EXPORT int           VpIsRoundMode(unsigned long n);
-VP_EXPORT unsigned long VpGetRoundMode(void);
-VP_EXPORT unsigned long VpSetRoundMode(unsigned long n);
+VP_EXPORT int            VpIsRoundMode(unsigned short n);
+VP_EXPORT unsigned short VpGetRoundMode(void);
+VP_EXPORT unsigned short VpSetRoundMode(unsigned short n);
 
 VP_EXPORT int VpException(unsigned short f,const char *str,int always);
-#if 0
+#if 0  /* unused */
 VP_EXPORT int VpIsNegDoubleZero(double v);
 #endif
-VP_EXPORT U_LONG VpNumOfChars(Real *vp,const char *pszFmt);
-VP_EXPORT U_LONG VpInit(U_LONG BaseVal);
-VP_EXPORT void *VpMemAlloc(U_LONG mb);
+VP_EXPORT size_t VpNumOfChars(Real *vp,const char *pszFmt);
+VP_EXPORT size_t VpInit(BDIGIT BaseVal);
+VP_EXPORT void *VpMemAlloc(size_t mb);
 VP_EXPORT void VpFree(Real *pv);
-VP_EXPORT Real *VpAlloc(U_LONG mx, const char *szVal);
-VP_EXPORT int VpAsgn(Real *c,Real *a,int isw);
-VP_EXPORT int VpAddSub(Real *c,Real *a,Real *b,int operation);
-VP_EXPORT int VpMult(Real *c,Real *a,Real *b);
-VP_EXPORT int VpDivd(Real *c,Real *r,Real *a,Real *b);
+VP_EXPORT Real *VpAlloc(size_t mx, const char *szVal);
+VP_EXPORT size_t VpAsgn(Real *c, Real *a, int isw);
+VP_EXPORT size_t VpAddSub(Real *c,Real *a,Real *b,int operation);
+VP_EXPORT size_t VpMult(Real *c,Real *a,Real *b);
+VP_EXPORT size_t VpDivd(Real *c,Real *r,Real *a,Real *b);
 VP_EXPORT int VpComp(Real *a,Real *b);
-VP_EXPORT S_LONG VpExponent10(Real *a);
+VP_EXPORT ssize_t VpExponent10(Real *a);
 VP_EXPORT void VpSzMantissa(Real *a,char *psz);
 VP_EXPORT int VpToSpecialString(Real *a,char *psz,int fPlus);
-VP_EXPORT void VpToString(Real *a,char *psz,int fFmt,int fPlus);
-VP_EXPORT void VpToFString(Real *a,char *psz,int fFmt,int fPlus);
-VP_EXPORT int VpCtoV(Real *a,const char *int_chr,U_LONG ni,const char *frac,U_LONG nf,const char *exp_chr,U_LONG ne);
-VP_EXPORT int VpVtoD(double *d,S_LONG *e,Real *m);
+VP_EXPORT void VpToString(Real *a, char *psz, size_t fFmt, int fPlus);
+VP_EXPORT void VpToFString(Real *a, char *psz, size_t fFmt, int fPlus);
+VP_EXPORT int VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, const char *exp_chr, size_t ne);
+VP_EXPORT int VpVtoD(double *d, SIGNED_VALUE *e, Real *m);
 VP_EXPORT void VpDtoV(Real *m,double d);
-#if 0
+#if 0  /* unused */
 VP_EXPORT void VpItoV(Real *m,S_INT ival);
 #endif
 VP_EXPORT int VpSqrt(Real *y,Real *x);
-VP_EXPORT int VpActiveRound(Real *y,Real *x,int f,int il);
-VP_EXPORT int VpMidRound(Real *y, int f, int nf);
-VP_EXPORT int VpLeftRound(Real *y, int f, int nf);
-VP_EXPORT void VpFrac(Real *y,Real *x);
-VP_EXPORT int VpPower(Real *y,Real *x,S_INT n);
+VP_EXPORT int VpActiveRound(Real *y, Real *x, unsigned short f, ssize_t il);
+VP_EXPORT int VpMidRound(Real *y, unsigned short f, ssize_t nf);
+VP_EXPORT int VpLeftRound(Real *y, unsigned short f, ssize_t nf);
+VP_EXPORT void VpFrac(Real *y, Real *x);
+VP_EXPORT int VpPower(Real *y, Real *x, SIGNED_VALUE n);
 
 /* VP constants */
 VP_EXPORT Real *VpOne(void);
 
-/*  
+/*
  *  ------------------
  *  MACRO definitions.
  *  ------------------
@@ -179,12 +236,12 @@ VP_EXPORT Real *VpOne(void);
 /* VpGetSign(a) returns 1,-1 if a>0,a<0 respectively */
 #define VpGetSign(a) (((a)->sign>0)?1:(-1))
 /* Change sign of a to a>0,a<0 if s = 1,-1 respectively */
-#define VpChangeSign(a,s) {if((s)>0) (a)->sign=(short)Abs((S_LONG)(a)->sign);else (a)->sign=-(short)Abs((S_LONG)(a)->sign);}
+#define VpChangeSign(a,s) {if((s)>0) (a)->sign=(short)Abs((ssize_t)(a)->sign);else (a)->sign=-(short)Abs((ssize_t)(a)->sign);}
 /* Sets sign of a to a>0,a<0 if s = 1,-1 respectively */
 #define VpSetSign(a,s)    {if((s)>0) (a)->sign=(short)VP_SIGN_POSITIVE_FINITE;else (a)->sign=(short)VP_SIGN_NEGATIVE_FINITE;}
 
 /* 1 */
-#define VpSetOne(a)       {(a)->frac[0]=(a)->exponent=(a)->Prec=1;(a)->sign=VP_SIGN_POSITIVE_FINITE;}
+#define VpSetOne(a)       {(a)->Prec=(a)->exponent=(a)->frac[0]=1;(a)->sign=VP_SIGN_POSITIVE_FINITE;}
 
 /* ZEROs */
 #define VpIsPosZero(a)  ((a)->sign==VP_SIGN_POSITIVE_ZERO)
@@ -209,12 +266,12 @@ VP_EXPORT Real *VpOne(void);
 #define VpHasVal(a)     (a->frac[0])
 #define VpIsOne(a)      ((a->Prec==1)&&(a->frac[0]==1)&&(a->exponent==1))
 #define VpExponent(a)   (a->exponent)
-#ifdef _DEBUG
+#ifdef BIGDECIMAL_DEBUG
 int VpVarCheck(Real * v);
-VP_EXPORT int VPrint(FILE *fp,char *cntl_chr,Real *a);
-#endif /* _DEBUG */
+VP_EXPORT int VPrint(FILE *fp,const char *cntl_chr,Real *a);
+#endif /* BIGDECIMAL_DEBUG */
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
-#endif /* ____BIG_DECIMAL__H____ */
+#endif /* RUBY_BIG_DECIMAL_H */

data/lib/bigdecimal/jacobian.rb

@@ -21,18 +21,20 @@
 # fx is f.values(x).
 #
 module Jacobian
+  module_function
+
   #--
   def isEqual(a,b,zero=0.0,e=1.0e-8)
     aa = a.abs
     bb = b.abs
     if aa == zero &&  bb == zero then
-          true
+      true
     else
-          if ((a-b)/(aa+bb)).abs < e then
-             true
-          else
-             false
-          end
+      if ((a-b)/(aa+bb)).abs < e then
+        true
+      else
+        false
+      end
     end
   end
   #++
@@ -52,17 +54,17 @@ module Jacobian
       s = f.zero
       deriv = []
       if(nRetry>100) then
-         raize "Singular Jacobian matrix. No change at x[" + i.to_s + "]"
+        raise "Singular Jacobian matrix. No change at x[" + i.to_s + "]"
       end
       dx = dx*f.two
       x[i] += dx
       fxNew = f.values(x)
       for j in 0...n do
         if !isEqual(fxNew[j],fx[j],f.zero,f.eps) then
-           ok += 1
-           deriv <<= (fxNew[j]-fx[j])/dx
+          ok += 1
+          deriv <<= (fxNew[j]-fx[j])/dx
         else
-           deriv <<= f.zero
+          deriv <<= f.zero
         end
       end
       x[i] = xSave
@@ -77,7 +79,7 @@ module Jacobian
     for i in 0...n do
       df = dfdxi(f,fx,x,i)
       for j in 0...n do
-         dfdx[j*n+i] = df[j]
+        dfdx[j*n+i] = df[j]
       end
     end
     dfdx

data/lib/bigdecimal/ludcmp.rb

@@ -1,7 +1,11 @@
+require 'bigdecimal'
+
 #
 # Solves a*x = b for x, using LU decomposition.
 #
 module LUSolve
+  module_function
+
   # Performs LU decomposition of the n by n matrix a.
   def ludecomp(a,n,zero=0,one=1)
     prec = BigDecimal.limit(nil)
@@ -12,24 +16,24 @@ module LUSolve
       nrmrow  = zero
       ixn = i*n
       for j in 0...n do
-         biggst = a[ixn+j].abs
-         nrmrow = biggst if biggst>nrmrow
+        biggst = a[ixn+j].abs
+        nrmrow = biggst if biggst>nrmrow
       end
       if nrmrow>zero then
-         scales <<= one.div(nrmrow,prec)
-      else 
-         raise "Singular matrix"
+        scales <<= one.div(nrmrow,prec)
+      else
+        raise "Singular matrix"
       end
     end
     n1          = n - 1
     for k in 0...n1 do # Gaussian elimination with partial pivoting.
       biggst  = zero;
       for i in k...n do
-         size = a[ps[i]*n+k].abs*scales[ps[i]]
-         if size>biggst then
-            biggst = size
-            pividx  = i
-         end
+        size = a[ps[i]*n+k].abs*scales[ps[i]]
+        if size>biggst then
+          biggst = size
+          pividx  = i
+        end
       end
       raise "Singular matrix" if biggst<=zero
       if pividx!=k then
@@ -42,10 +46,10 @@ module LUSolve
         psin = ps[i]*n
         a[psin+k] = mult = a[psin+k].div(pivot,prec)
         if mult!=zero then
-           pskn = ps[k]*n
-           for j in (k+1)...n do
-             a[psin+j] -= mult.mult(a[pskn+j],prec)
-           end
+          pskn = ps[k]*n
+          for j in (k+1)...n do
+            a[psin+j] -= mult.mult(a[pskn+j],prec)
+          end
         end
       end
     end
@@ -72,12 +76,12 @@ module LUSolve
       x <<= b[ps[i]] - dot
     end
     (n-1).downto(0) do |i|
-       dot = zero
-       psin = ps[i]*n
-       for j in (i+1)...n do
-         dot = a[psin+j].mult(x[j],prec) + dot
-       end
-       x[i]  = (x[i]-dot).div(a[psin+i],prec)
+      dot = zero
+      psin = ps[i]*n
+      for j in (i+1)...n do
+        dot = a[psin+j].mult(x[j],prec) + dot
+      end
+      x[i]  = (x[i]-dot).div(a[psin+i],prec)
     end
     x
   end

data/lib/bigdecimal/math.rb

@@ -1,3 +1,5 @@
+require 'bigdecimal'
+
 #
 #--
 # Contents:
@@ -5,7 +7,6 @@
 #   sin (x, prec)
 #   cos (x, prec)
 #   atan(x, prec)  Note: |x|<1, x=0.9999 may not converge.
-#   exp (x, prec)
 #   log (x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
@@ -29,11 +30,12 @@
 #   puts sin(a,100) # -> 0.10000000000000000000......E1
 #
 module BigMath
+  module_function
 
-  # Computes the square root of x to the specified number of digits of 
+  # Computes the square root of x to the specified number of digits of
   # precision.
   #
-  # BigDecimal.new('2').sqrt(16).to_s 
+  # BigDecimal.new('2').sqrt(16).to_s
   #  -> "0.14142135623730950488016887242096975E1"
   #
   def sqrt(x,prec)
@@ -49,6 +51,14 @@ module BigMath
     n    = prec + BigDecimal.double_fig
     one  = BigDecimal("1")
     two  = BigDecimal("2")
+    x = -x if neg = x < 0
+    if x > (twopi = two * BigMath.PI(prec))
+      if x > 30
+        x %= twopi
+      else
+        x -= twopi while x > twopi
+      end
+    end
     x1   = x
     x2   = x.mult(x,n)
     sign = 1
@@ -65,7 +75,7 @@ module BigMath
       d   = sign * x1.div(z,m)
       y  += d
     end
-    y
+    neg ? -y : y
   end
 
   # Computes the cosine of x to the specified number of digits of precision.
@@ -77,6 +87,14 @@ module BigMath
     n    = prec + BigDecimal.double_fig
     one  = BigDecimal("1")
     two  = BigDecimal("2")
+    x = -x if x < 0
+    if x > (twopi = two * BigMath.PI(prec))
+      if x > 30
+        x %= twopi
+      else
+        x -= twopi while x > twopi
+      end
+    end
     x1 = one
     x2 = x.mult(x,n)
     sign = 1
@@ -98,12 +116,16 @@ module BigMath
 
   # Computes the arctangent of x to the specified number of digits of precision.
   #
-  # If x is infinite or NaN, returns NaN.
-  # Raises an argument error if x > 1.
+  # If x is NaN, returns NaN.
   def atan(x, prec)
     raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
-    return BigDecimal("NaN") if x.infinite? || x.nan?
-    raise ArgumentError, "x.abs must be less than 1.0" if x.abs>=1
+    return BigDecimal("NaN") if x.nan?
+    pi = PI(prec)
+    x = -x if neg = x < 0
+    return pi.div(neg ? -2 : 2, prec) if x.infinite?
+    return pi / (neg ? -4 : 4) if x.round(prec) == 1
+    x = BigDecimal("1").div(x, prec) if inv = x > 1
+    x = (-1 + sqrt(1 + x**2, prec))/x if dbl = x > 0.5
     n    = prec + BigDecimal.double_fig
     y = x
     d = y
@@ -117,63 +139,12 @@ module BigMath
       y += d
       r += 2
     end
+    y *= 2 if dbl
+    y = pi / 2 - y if inv
+    y = -y if neg
     y
   end
 
-  # Computes the value of e (the base of natural logarithms) raised to the 
-  # power of x, to the specified number of digits of precision.
-  #
-  # If x is infinite or NaN, returns NaN.
-  #
-  # BigMath::exp(BigDecimal.new('1'), 10).to_s
-  # -> "0.271828182845904523536028752390026306410273E1"
-  def exp(x, prec)
-    raise ArgumentError, "Zero or negative precision for exp" if prec <= 0
-    return BigDecimal("NaN") if x.infinite? || x.nan?
-    n    = prec + BigDecimal.double_fig
-    one  = BigDecimal("1")
-    x1 = one
-    y  = one
-    d  = y
-    z  = one
-    i  = 0
-    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      x1  = x1.mult(x,n)
-      i += 1
-      z *= i
-      d  = x1.div(z,m)
-      y += d
-    end
-    y
-  end
-
-  # Computes the natural logarithm of x to the specified number of digits 
-  # of precision.
-  #
-  # Returns x if x is infinite or NaN.
-  #
-  def log(x, prec)
-    raise ArgumentError, "Zero or negative argument for log" if x <= 0 || prec <= 0
-    return x if x.infinite? || x.nan?
-    one = BigDecimal("1")
-    two = BigDecimal("2")
-    n  = prec + BigDecimal.double_fig
-    x  = (x - one).div(x + one,n)
-    x2 = x.mult(x,n)
-    y  = x
-    d  = y
-    i = one
-    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      x  = x2.mult(x,n)
-      i += two
-      d  = x.div(i,m)
-      y += d
-    end
-    y*two
-  end
-
   # Computes the value of pi to the specified number of digits of precision.
   def PI(prec)
     raise ArgumentError, "Zero or negative argument for PI" if prec <= 0