decimal 0.1.0 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8097ff905177fba0cb30a72729889f1f0e8c2a5
+  data.tar.gz: ca7f019d9016491724ced8f63dc8014a9b36f336
+SHA512:
+  metadata.gz: 9aae38f7a8bff309748cd1c61279323411c39bcf5238c95539d27e5d98b4ede7a6e7b3ed2f712b01490e386ce03d669c493ca5e75aff600ab4246f45d0d4901e
+  data.tar.gz: 475772f7f6cc6e888743d1b0b66696fe90a98f5a46022b023049ac5c554ce59f3d3fbc3bd4ac205c31435ec8123513f34c6eea1d395d86f50caae9e2ba07bc69

data/.document

@@ -1,3 +1,2 @@
 decimal.c
-README
-
+README.rdoc

data/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2014 Tadashi Saito. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/COPYING

@@ -1,7 +1,7 @@
 Decimal is copyrighted free software by Tadashi Saito <tad.a.diggier[at]
 gmail.com>.
-You can redistribute it and/or modify it under either the terms of the GPL
-version 2 (see the file GPL), or the conditions below:
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
 
   1. You may make and give away verbatim copies of the source form of the
      software without restriction, provided that you duplicate all of the

data/{README → README.rdoc}

@@ -7,13 +7,14 @@ precise, stable and easy-to-use solution.
 == Webpages
 
 * {Home}[http://decimal.rubyforge.org/]
+* {GitHub}[https://github.com/tadd/decimal]
 * {Latest API Documents}[http://decimal.rubyforge.org/rdoc/]
 * {Project Page at RubyForge}[http://rubyforge.org/projects/decimal/]
 * {Mailing Lists}[http://rubyforge.org/mail/?group_id=1994]
 
 == Requirements
 
-Ruby 1.8.6 / 1.8.7 / 1.9.1 / 1.9.2dev (experimental)
+Ruby 1.9.3 / 2.0.0 / 2.1.x / 2.2.x
 
 == Install
 
@@ -50,7 +51,7 @@ Use like Float with few exceptions including Decimal#divide.
 
 == License
 
-Ruby's.  See COPYING and GPL for more details.
+Ruby's.  See COPYING and BSDL for more details.
 
 == Author
 

data/TODO

@@ -1,7 +1,5 @@
 * Preserve scale of zeros
 * Implement "decimal/compat/bigdecimal", a bigdecimal-compatible layer
-* Implement decimal ** otherdecimal, decimal ** -integer
-  (with Decimal#power(other, scale=decimal.scale, mode=Decimal::ROUND_XXX))
 * Be a good friend with other Numeric classes (using Kernel.autoload?)
   - OtherNumerics#to_decimal, Decimal#to_*
 * Define `marshal_dump' and `marshal_load'
@@ -13,6 +11,7 @@
 * Static value for well-used value like 0, 1 or 10 ?
 
 done:
+- Implement decimal ** otherdecimal and decimal ** -integer
 - Implement Math functions
 - Implement webpages
 - Support RubyGems

data/decimal.c

@@ -23,9 +23,6 @@
 #include <util.h>
 #endif
 
-/* we need support both of 1.8/1.9 with the same source! */
-#include "ruby18compat.h"
-
 /*
  * unfortunately, few copies of Integer functions
  * are needed from original Ruby
@@ -772,7 +769,7 @@ do_round(const Decimal *d, long scale, VALUE mode, VALUE *inump)
     long diff;
     int lower;
     int trailing_nonzero, negative;
-    VALUE inum, inumabs, shift, ary;
+    VALUE inum = Qundef, inumabs, shift, ary;
 
     if (d == DEC_PINF) rb_raise(eDomainError, "Infinity");
     if (d == DEC_NINF) rb_raise(eDomainError, "-Infinity");
@@ -1027,7 +1024,6 @@ divmod(const Decimal *a, const Decimal *b, VALUE *divp, VALUE *modp)
     }
     else if (DEC_ISINF(b)) {
 	const int a_negative = INUM_NEGATIVE_P(a->inum);
-	VALUE div_inum;
 
 	if (a_negative != (b == DEC_NINF)) { /* signs differ */
             if (divp) *divp = INT2FIX(-1);
@@ -1177,19 +1173,173 @@ dec_divmod(VALUE x, VALUE y)
     return rb_assoc_new(div, mod);
 }
 
+static VALUE math_ln(VALUE x, VALUE scale, VALUE mode);
+static VALUE math_exp(int argc, VALUE *argv, VALUE module UNUSED);
+
 static VALUE
-power_with_fixnum(const Decimal *x, VALUE y)
+power_with_math_exp(VALUE x, VALUE y, VALUE scale, VALUE mode)
+{
+    VALUE x_ln;
+    VALUE argv[3];
+
+    x_ln = math_ln(x, LONG2NUM(FIX2LONG(scale)+1), ROUND_DOWN);
+    argv[0] = dec_mul(y, x_ln);
+    argv[1] = scale;
+    argv[2] = mode;
+    return math_exp(3, argv, Qnil);
+}
+
+static VALUE
+power_with_positive_fixnum(VALUE x, VALUE y)
 {
     VALUE inum;
+    Decimal *a;
 
+    GetDecimal(x, a);
     /* XXX: valid to rb_warn() out of here by rb_big_pow()? */
-    inum = INUM_POW(x->inum, y);
+    inum = INUM_POW(a->inum, y);
     if (TYPE(inum) == T_FLOAT) /* got Infinity with warning, by too-big y */
         return VALUE_PINF;
-    return WrapDecimal(dec_raw_new(inum, x->scale * FIX2LONG(y)));
+    return WrapDecimal(dec_raw_new(inum, a->scale * FIX2LONG(y)));
+}
+
+static VALUE dec_eq(VALUE x, VALUE y);
+static VALUE dec_lt(VALUE x, VALUE y);
+static VALUE dec_gt(VALUE x, VALUE y);
+static VALUE dec_abs(VALUE x);
+static VALUE dec_zero_p(VALUE x);
+static VALUE dec_finite_p(VALUE x);
+
+static VALUE
+power_body(VALUE x, VALUE y, VALUE scale, VALUE mode)
+{
+    int y_negative_p, y_finite_p, y_integer_p, y_zero_p, y_positive_p,
+        y_odd_p, y_pinf_p, y_ninf_p, y_nan_p, y_one_p;
+    int x_finite_p, x_negative_p, x_nan_p, x_pone_p, x_none_p, x_zero_p,
+        x_abs, x_abs_lt_1, x_abs_gt_1, x_ninf_p, x_pinf_p;
+    long l = 0; /* dummy value */
+
+    if (FIXNUM_P(y)) {
+        l = FIX2LONG(y);
+        y_integer_p = y_finite_p = Qtrue;
+        y_zero_p = (l == 0);
+        y_one_p = (l == 1);
+        y_positive_p = (l > 0);
+        y_negative_p = (l < 0);
+        y_odd_p = (l % 2 != 0);
+        y_pinf_p = y_ninf_p = y_nan_p = Qfalse;
+    } else { /* it's a Decimal */
+        y_finite_p = dec_finite_p(y);
+        y_integer_p = (y_finite_p && !dec_zero_p(dec_mod(y, INT2FIX(1))));
+        y_zero_p = dec_zero_p(y);
+        y_one_p = dec_eq(y, INT2FIX(1));
+        y_positive_p = dec_gt(y, INT2FIX(0));
+        y_negative_p = dec_lt(y, INT2FIX(0));
+        y_odd_p = (y_finite_p && !dec_zero_p(dec_mod(y, INT2FIX(2))));
+        y_pinf_p = (y == VALUE_PINF);
+        y_ninf_p = (y == VALUE_NINF);
+        y_nan_p = (y == VALUE_NaN);
+    }
+    x_finite_p = dec_finite_p(x);
+    x_negative_p = dec_lt(x, INT2FIX(0));
+    x_nan_p = (x == VALUE_NaN);
+    x_pone_p = dec_eq(x, INT2FIX(1));
+    x_none_p = dec_eq(x, INT2FIX(-1));
+    x_zero_p = dec_zero_p(x);
+    x_abs = dec_abs(x);
+    x_abs_lt_1 = dec_lt(x_abs, INT2FIX(1));
+    x_abs_gt_1 = dec_gt(x_abs, INT2FIX(1));
+    x_ninf_p = (x == VALUE_NINF);
+    x_pinf_p = (x == VALUE_PINF);
+
+    if (x_negative_p && x_finite_p && !y_integer_p && y_finite_p) {
+        rb_raise(rb_eArgError, "in a**b, a is negative and b is not integer");
+    }
+    if (x_pone_p || y_zero_p) {
+        return WrapDecimal(dec_raw_new(INT2FIX(1), 0));
+    }
+    if (x_zero_p && y_positive_p) {
+        return WrapDecimal(dec_raw_new(DEC_PZERO, 0));
+    }
+    if (x_none_p && (y_pinf_p || y_ninf_p)) {
+        return WrapDecimal(dec_raw_new(INT2FIX(1), 0));
+    }
+    if (x_abs_lt_1 && y_ninf_p) {
+        return VALUE_PINF;
+    }
+    if ((x_abs_gt_1 && y_ninf_p) || (x_abs_lt_1 && y_pinf_p)) {
+        return WrapDecimal(dec_raw_new(DEC_PZERO, 0));
+    }
+    if (x_abs_gt_1 && y_pinf_p) {
+        return VALUE_PINF;
+    }
+    if (x_ninf_p) {
+        if (y_negative_p) {
+            return WrapDecimal(dec_raw_new(DEC_PZERO, 0));
+        }
+        if (y_positive_p) {
+            return y_odd_p ? VALUE_NINF : VALUE_PINF;
+        }
+    }
+    if (x_pinf_p) {
+        if (y_negative_p) {
+            return WrapDecimal(dec_raw_new(DEC_PZERO, 0));
+        }
+        if (y_positive_p) {
+            return VALUE_PINF;
+        }
+    }
+    if (x_zero_p && y_negative_p) {
+         /* FIXME; pole error? */
+        rb_raise(rb_eArgError, "in a**b, a is 0 and y is negative");
+    }
+    if (x_nan_p || y_nan_p) {
+        return VALUE_NaN;
+    }
+    if (y_one_p) return x;
+    if (FIXNUM_P(y)) {
+        if (l > 0) return power_with_positive_fixnum(x, y);
+        y = WrapDecimal(inum_to_dec(y));
+    }
+    return power_with_math_exp(x, y, scale, mode);
+}
+
+/*
+ *  dec.power(otherdec, scale=(), rounding=:unnecessary)
+ */
+/* :nodoc: */
+static VALUE
+dec_power(int argc, VALUE *argv, VALUE x)
+{
+    VALUE mode = ROUND_UNNECESSARY;
+    VALUE y, scale, vmode;
+
+    rb_scan_args(argc, argv, "12", &y, &scale, &vmode);
+    switch (argc) {
+      case 3:
+        Check_Type(vmode, T_SYMBOL);
+	if (!valid_rounding_mode_p(vmode)) {
+	    rb_raise(rb_eArgError, "invalid rounding mode %s",
+                     RSTRING_PTR(rb_inspect(vmode)));
+	}
+	mode = vmode;
+	/* fall through */
+    case 2:
+        Check_Type(scale, T_FIXNUM);
+        break;
+    case 1:
+	if (mode != ROUND_UNNECESSARY) {
+	    rb_raise(rb_eArgError, "scale number argument needed");
+	}
+    }
+
+    if (!FIXNUM_P(y) && !DECIMAL_P(y)) {
+        rb_raise(rb_eTypeError, "2nd argument %s must be Fixnum or Decimal",
+                 RSTRING_PTR(rb_inspect(y)));
+    }
+    return power_body(x, y, scale, mode);
 }
 
-/* TODO: implement dec ** otherdec */
 /*
  *  call-seq:
  *     dec ** fix   => decimal
@@ -1201,26 +1351,7 @@ power_with_fixnum(const Decimal *x, VALUE y)
 static VALUE
 dec_pow(VALUE x, VALUE y)
 {
-    Decimal *a;
-    long l;
-
-    CHECK_NAN(x);
-    Check_Type(y, T_FIXNUM);
-    l = FIX2LONG(y);
-    if (l < 0) rb_raise(rb_eArgError, "in a**b, b should be positive integer");
-    if (l == 0) return WrapDecimal(dec_raw_new(INT2FIX(1), 0));
-    if (l == 1) return x;
-
-    if (x == VALUE_PINF) return x;
-    if (x == VALUE_NINF) {
-	return l % 2 == 0 ? VALUE_PINF : VALUE_NINF;
-    }
-    GetDecimal(x, a);
-    if (a->inum == DEC_PZERO) return x;
-    if (a->inum == DEC_NZERO) {
-	return l % 2 == 0 ? dec_uminus(x) : x;
-    }
-    return power_with_fixnum(a, y);
+    return dec_power(1, &y, x);
 }
 
 static int
@@ -1890,7 +2021,7 @@ math_ldexp10(VALUE module UNUSED, VALUE x, VALUE exp)
     if (DEC_VALUE_ISINF(x))
         return x;
 
-    if (TYPE(x) == T_FIXNUM || TYPE(x) == T_BIGNUM) {
+    if (FIXNUM_P(x) || TYPE(x) == T_BIGNUM) {
         integer = Qtrue;
         d = inum_to_dec(x);
     }
@@ -1922,7 +2053,7 @@ math_frexp10(VALUE module UNUSED, VALUE x)
     if (DEC_VALUE_ISINF(x))
         return rb_assoc_new(x, INT2FIX(0));
 
-    if (TYPE(x) == T_FIXNUM || TYPE(x) == T_BIGNUM) {
+    if (FIXNUM_P(x) || TYPE(x) == T_BIGNUM) {
         integer = Qtrue;
         d = inum_to_dec(x);
     }
@@ -1971,6 +2102,100 @@ math_frexp10(VALUE module UNUSED, VALUE x)
     return rb_assoc_new(WrapDecimal(mant), LONG2NUM(exp));
 }
 
+/* :nodoc: */
+static VALUE
+math_exp(int argc, VALUE *argv, VALUE module UNUSED) /* (x, scale, rounding=:down) */
+{
+    VALUE x, scale, mode;
+    int negative;
+    VALUE z, x1, y, i, d;
+    VALUE argv2[3]; /* for divide / round */
+
+    rb_scan_args(argc, argv, "21", &x, &scale, &mode);
+    switch (argc) {
+      case 3:
+	Check_Type(mode, T_SYMBOL);
+	if (!valid_rounding_mode_p(mode)) {
+	    rb_raise(rb_eArgError, "invalid rounding mode %s",
+                     RSTRING_PTR(rb_inspect(mode)));
+	}
+	/* fall through */
+      default:
+        Check_Type(scale, T_FIXNUM);
+	if (NIL_P(mode)) mode = ROUND_DOWN;
+	break;
+    }
+    if (FIXNUM_P(x) || TYPE(x) == T_BIGNUM) x = WrapDecimal(inum_to_dec(x));
+    if (dec_nan_p(x)) return VALUE_NaN;
+    if (dec_zero_p(x)) return WrapDecimal(dec_raw_new(INT2FIX(1), 0));
+    if (dec_infinite_p(x) != Qnil) {
+	if (x == VALUE_PINF)
+            return VALUE_PINF;
+        return WrapDecimal(dec_raw_new(DEC_PZERO, 0));
+    }
+    negative = dec_lt(x, INT2FIX(0));
+    if (negative) x = dec_uminus(x);
+
+    y = WrapDecimal(dec_raw_new(INT2FIX(1), 0));
+    x1 = WrapDecimal(dec_raw_new(INT2FIX(1), 0));
+    z = INT2FIX(1);
+    i = INT2FIX(0);
+    argv2[1] = INUM_PLUS(scale, INT2FIX(1));
+    argv2[2] = ROUND_DOWN;
+    for (;;) {
+	x1 = dec_mul(x1, x);
+	INUM_INC(i);
+	z = INUM_MUL(z, i);
+	argv2[0] = z;
+	d = dec_divide(3, argv2, x1);
+	if (dec_zero_p(d)) break;
+	y = dec_plus(y, d);
+    }
+    if (negative) {
+	argv2[0] = y;
+	argv2[1] = scale;
+	argv2[2] = mode;
+	y = dec_divide(3, argv2, WrapDecimal(dec_raw_new(INT2FIX(1), 0)));
+    } else {
+	argv2[0] = scale;
+	argv2[1] = mode;
+	y = dec_round(2, argv2, y);
+    }
+    return y;
+}
+
+/* internal use only */
+static VALUE
+math_ln(VALUE x, VALUE scale, VALUE mode)
+{
+    VALUE u, u2, i, d, y;
+    VALUE argv[3], scale_more;
+    
+    if (dec_eq(x, INT2FIX(1))) return WrapDecimal(dec_raw_new(DEC_PZERO, 0));
+
+    scale_more = LONG2FIX(FIX2LONG(scale) + 1);
+    argv[0] = dec_plus(x, INT2FIX(1));
+    argv[1] = scale_more;
+    argv[2] = ROUND_DOWN;
+    u  = dec_divide(3, argv, dec_minus(x, INT2FIX(1)));
+
+    u2 = dec_mul(u, u);
+    y = u;
+    i = INT2FIX(1);
+    for (;;) {
+        u = dec_floor(1, &scale_more, dec_mul(u, u2));
+        i = INUM_PLUS(i, INT2FIX(2));
+        argv[0] = i;
+        d = dec_divide(3, argv, u);
+        if (dec_zero_p(d)) break;
+        y = dec_plus(y, d);
+    }
+    y = dec_mul(y, INT2FIX(2));
+    argv[0] = scale;
+    argv[1] = mode;
+    return dec_round(2, argv, y);
+}
+
 /* initialize minimum Math functions in C */
 /* not documented yet. */
 static void
@@ -1979,6 +2204,7 @@ init_math(void)
     mMath = rb_define_module_under(cDecimal, "Math");
     rb_define_module_function(mMath, "ldexp10", math_ldexp10, 2);
     rb_define_module_function(mMath, "frexp10", math_frexp10, 1);
+    rb_define_module_function(mMath, "exp", math_exp, -1);
 }
 
 
@@ -2071,6 +2297,7 @@ Init_decimal(void)
     rb_define_method(cDecimal, "%", dec_mod, 1);
     rb_define_method(cDecimal, "modulo", dec_mod, 1);
     rb_define_method(cDecimal, "divmod", dec_divmod, 1);
+    rb_define_method(cDecimal, "power", dec_power, -1);
     rb_define_method(cDecimal, "**", dec_pow, 1);
     rb_define_method(cDecimal, "==", dec_eq, 1);
     rb_define_method(cDecimal, "<=>", dec_cmp, 1);