rubysl-bigdecimal 1.0.0

data/spec/case_compare_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/eql.rb', __FILE__)
+
+
+describe "BigDecimal#===" do
+  it_behaves_like(:bigdecimal_eql, :===)
+end

data/spec/ceil_spec.rb

@@ -0,0 +1,122 @@
+require 'bigdecimal'
+
+describe "BigDecimal#ceil" do
+  before(:each) do
+    @zero = BigDecimal("0")
+    @one = BigDecimal("1")
+    @three = BigDecimal("3")
+    @four = BigDecimal("4")
+    @mixed = BigDecimal("1.23456789")
+    @mixed_big = BigDecimal("1.23456789E100")
+    @pos_int = BigDecimal("2E5555")
+    @neg_int = BigDecimal("-2E5555")
+    @pos_frac = BigDecimal("2E-9999")
+    @neg_frac = BigDecimal("-2E-9999")
+
+    @infinity = BigDecimal("Infinity")
+    @infinity_neg = BigDecimal("-Infinity")
+    @nan = BigDecimal("NaN")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = BigDecimal("-0")
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "returns a BigDecimal" do
+      @mixed.ceil.kind_of?(BigDecimal).should == true
+      @pos_int.ceil(2).kind_of?(BigDecimal).should == true
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "returns an Integer, if n is unspecified" do
+      @mixed.ceil.kind_of?(Integer).should == true
+    end
+
+    it "returns a BigDecimal, if n is specified" do
+      @pos_int.ceil(2).kind_of?(BigDecimal).should == true
+    end
+  end
+
+  it "returns the smallest integer greater or equal to self, if n is unspecified" do
+    @pos_int.ceil.should == @pos_int
+    @neg_int.ceil.should == @neg_int
+    @pos_frac.ceil.should == BigDecimal("1")
+    @neg_frac.ceil.should == @zero
+    @zero.ceil.should == 0
+    @zero_pos.ceil.should == @zero_pos
+    @zero_neg.ceil.should == @zero_neg
+
+
+    BigDecimal('2.3').ceil.should == 3
+    BigDecimal('2.5').ceil.should == 3
+    BigDecimal('2.9999').ceil.should == 3
+    BigDecimal('-2.3').ceil.should == -2
+    BigDecimal('-2.5').ceil.should == -2
+    BigDecimal('-2.9999').ceil.should == -2
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "returns the same value, if self is special value" do
+      @infinity.ceil.should == @infinity
+      @infinity_neg.ceil.should == @infinity_neg
+      @nan.ceil.nan?.should == true
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raise exception, if self is special value" do
+      lambda { @infinity.ceil }.should raise_error(FloatDomainError)
+      lambda { @infinity_neg.ceil }.should raise_error(FloatDomainError)
+      lambda { @nan.ceil }.should raise_error(FloatDomainError)
+    end
+  end
+
+  it "returns n digits right of the decimal point if given n > 0" do
+    @mixed.ceil(1).should == BigDecimal("1.3")
+    @mixed.ceil(5).should == BigDecimal("1.23457")
+
+    BigDecimal("-0.03").ceil(1).should == BigDecimal("0")
+    BigDecimal("0.03").ceil(1).should == BigDecimal("0.1")
+
+    BigDecimal("23.45").ceil(0).should == BigDecimal('24')
+    BigDecimal("23.45").ceil(1).should == BigDecimal('23.5')
+    BigDecimal("23.45").ceil(2).should == BigDecimal('23.45')
+
+    BigDecimal("-23.45").ceil(0).should == BigDecimal('-23')
+    BigDecimal("-23.45").ceil(1).should == BigDecimal('-23.4')
+    BigDecimal("-23.45").ceil(2).should == BigDecimal('-23.45')
+
+    BigDecimal("2E-10").ceil(0).should == @one
+    BigDecimal("2E-10").ceil(9).should == BigDecimal('1E-9')
+    BigDecimal("2E-10").ceil(10).should == BigDecimal('2E-10')
+    BigDecimal("2E-10").ceil(11).should == BigDecimal('2E-10')
+
+    (1..10).each do |n|
+      # 0.4, 0.34, 0.334, etc.
+      (@one.div(@three,20)).ceil(n).should == BigDecimal("0.#{'3'*(n-1)}4")
+      # 1.4, 1.34, 1.334, etc.
+      (@four.div(@three,20)).ceil(n).should == BigDecimal("1.#{'3'*(n-1)}4")
+      (BigDecimal('31').div(@three,20)).ceil(n).should == BigDecimal("10.#{'3'*(n-1)}4")
+    end
+    (1..10).each do |n|
+      # -0.4, -0.34, -0.334, etc.
+      (-@one.div(@three,20)).ceil(n).should == BigDecimal("-0.#{'3'* n}")
+    end
+    (1..10).each do |n|
+      (@three.div(@one,20)).ceil(n).should == @three
+    end
+    (1..10).each do |n|
+      (-@three.div(@one,20)).ceil(n).should == -@three
+    end
+  end
+
+  it "sets n digits left of the decimal point to 0, if given n < 0" do
+    BigDecimal("13345.234").ceil(-2).should == BigDecimal("13400.0")
+    @mixed_big.ceil(-99).should == BigDecimal("0.13E101")
+    @mixed_big.ceil(-100).should == BigDecimal("0.2E101")
+    @mixed_big.ceil(-95).should == BigDecimal("0.123457E101")
+    BigDecimal("1E10").ceil(-30).should == BigDecimal('1E30')
+    BigDecimal("-1E10").ceil(-30).should == @zero
+  end
+
+end

data/spec/coerce_spec.rb

@@ -0,0 +1,25 @@
+require 'bigdecimal'
+
+describe "BigDecimal#coerce" do
+
+  it "returns [other, self] both as BigDecimal" do
+    one = BigDecimal("1.0")
+    five_point_28 = BigDecimal("5.28")
+    zero_minus = BigDecimal("-0.0")
+    some_value = 32434234234234234234
+
+    BigDecimal("1.2").coerce(1).should == [one, BigDecimal("1.2")]
+    five_point_28.coerce(1.0).should == [one, BigDecimal("5.28")]
+    one.coerce(one).should == [one, one]
+    one.coerce(2.5).should == [2.5, one]
+    BigDecimal("1").coerce(3.14).should == [3.14, one]
+    a, b = zero_minus.coerce(some_value)
+    a.should == BigDecimal(some_value.to_s)
+    b.should == zero_minus
+    a, b = one.coerce(some_value)
+    a.should == BigDecimal(some_value.to_s)
+    b.to_f.should be_close(1.0, TOLERANCE) # can we take out the to_f once BigDecimal#- is implemented?
+    b.should == one
+  end
+
+end

data/spec/comparison_spec.rb

@@ -0,0 +1,80 @@
+require 'bigdecimal'
+
+describe "BigDecimal#<=>" do
+  before(:each) do
+    @zero = BigDecimal("0")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = BigDecimal("-0")
+    @mixed = BigDecimal("1.23456789")
+    @mixed_big = BigDecimal("1.23456789E100")
+    @pos_int = BigDecimal("2E5555")
+    @neg_int = BigDecimal("-2E5555")
+    @pos_frac = BigDecimal("2E-9999")
+    @neg_frac = BigDecimal("-2E-9999")
+
+    @int_mock = mock('123')
+    class << @int_mock
+      def coerce(other)
+        return [other, BigDecimal('123')]
+      end
+      def >= (other)
+        BigDecimal('123') >= other
+      end
+    end
+
+    @values = [@mixed, @pos_int, @neg_int, @pos_frac, @neg_frac,
+      -2**32, -2**31, -2**30, -2**16, -2**8, -100, -10, -1,
+      @zero , 1, 2, 10, 2**8, 2**16, 2**32, @int_mock, @zero_pos, @zero_neg]
+
+    @infinity = BigDecimal("Infinity")
+    @infinity_neg = BigDecimal("-Infinity")
+    @nan = BigDecimal("NaN")
+  end
+
+
+  it "returns 0 if a == b" do
+    (@pos_int <=> @pos_int).should == 0
+    (@neg_int <=> @neg_int).should == 0
+    (@pos_frac <=> @pos_frac).should == 0
+    (@neg_frac <=> @neg_frac).should == 0
+    (@zero <=> @zero).should == 0
+    (@infinity <=> @infinity).should == 0
+    (@infinity_neg <=> @infinity_neg).should == 0
+  end
+
+  it "returns 1 if a > b" do
+    (@pos_int <=> @neg_int).should == 1
+    (@pos_frac <=> @neg_frac).should == 1
+    (@pos_frac <=> @zero).should == 1
+    @values.each { |val|
+      (@infinity <=> val).should == 1
+    }
+  end
+
+  it "returns -1 if a < b" do
+    (@zero <=> @pos_frac).should == -1
+    (@neg_int <=> @pos_frac).should == -1
+    (@pos_frac <=> @pos_int).should == -1
+    @values.each { |val|
+      (@infinity_neg <=> val).should == -1
+    }
+  end
+
+  it "returns nil if NaN is involved" do
+    @values += [@infinity, @infinity_neg, @nan]
+    @values << nil
+    @values << Object.new
+    @values.each { |val|
+      (@nan <=> val).should == nil
+    }
+  end
+
+  it "returns nil if the argument is nil" do
+    (@zero <=> nil).should == nil
+    (@infinity <=> nil).should == nil
+    (@infinity_neg <=> nil).should == nil
+    (@mixed <=> nil).should == nil
+    (@pos_int <=> nil).should == nil
+    (@neg_frac <=> nil).should == nil
+  end
+end

data/spec/div_spec.rb

@@ -0,0 +1,143 @@
+require File.expand_path('../shared/quo', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#div with precision set to 0" do
+  # TODO: figure out if there is a better way to do these
+  # shared specs rather than sending [0]. See other specs
+  # that share :bigdecimal_quo.
+  it_behaves_like :bigdecimal_quo, :div, [0]
+end
+
+describe "BigDecimal#div" do
+
+  before(:each) do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @zero_plus = BigDecimal("+0")
+    @zero_minus = BigDecimal("-0")
+    @two = BigDecimal("2")
+    @three = BigDecimal("3")
+    @nan = BigDecimal("NaN")
+    @infinity = BigDecimal("Infinity")
+    @infinity_minus = BigDecimal("-Infinity")
+    @one_minus = BigDecimal("-1")
+    @frac_1 = BigDecimal("1E-99999")
+    @frac_2 = BigDecimal("0.9E-99999")
+  end
+
+  it "returns a / b with optional precision" do
+    @two.div(@one).should == @two
+    @one.div(@two).should == @zero
+    # ^^ is this really intended for a class with arbitrary precision?
+    @one.div(@two, 1).should == BigDecimal("0.5")
+    @one.div(@one_minus).should == @one_minus
+    @one_minus.div(@one_minus).should == @one
+    @frac_2.div(@frac_1, 1).should == BigDecimal("0.9")
+    @frac_1.div(@frac_1).should == @one
+
+    res = "0." + "3" * 1000
+    (1..100).each { |idx|
+      @one.div(@three, idx).to_s("F").should == "0." + res[2, idx]
+    }
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "returns NaN if NaN is involved" do
+      @one.div(@nan).nan?.should == true
+      @nan.div(@one).nan?.should == true
+    end
+
+    it "returns NaN if divided by Infinity and no precision given" do
+      @zero.div(@infinity).nan?.should == true
+      @frac_2.div(@infinity).nan?.should == true
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises FloatDomainError if NaN is involved" do
+      lambda { @one.div(@nan) }.should raise_error(FloatDomainError)
+      lambda { @nan.div(@one) }.should raise_error(FloatDomainError)
+    end
+
+    it "returns 0 if divided by Infinity and no precision given" do
+      @zero.div(@infinity).should == 0
+      @frac_2.div(@infinity).should == 0
+    end
+  end
+
+  it "returns 0 if divided by Infinity with given precision" do
+    @zero.div(@infinity, 0).should == 0
+    @frac_2.div(@infinity, 1).should == 0
+    @zero.div(@infinity, 100000).should == 0
+    @frac_2.div(@infinity, 100000).should == 0
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "returns NaN if divided by zero and no precision given" do
+      @one.div(@zero).nan?.should == true
+      @one.div(@zero_plus).nan?.should == true
+      @one.div(@zero_minus).nan?.should == true
+    end
+
+    it "returns NaN if zero is divided by zero" do
+      @zero.div(@zero).nan?.should == true
+      @zero_minus.div(@zero_plus).nan?.should == true
+      @zero_plus.div(@zero_minus).nan?.should == true
+
+      @zero.div(@zero, 0).nan?.should == true
+      @zero_minus.div(@zero_plus, 0).nan?.should == true
+      @zero_plus.div(@zero_minus, 0).nan?.should == true
+
+      @zero.div(@zero, 10).nan?.should == true
+      @zero_minus.div(@zero_plus, 10).nan?.should == true
+      @zero_plus.div(@zero_minus, 10).nan?.should == true
+    end
+
+    it "returns NaN if (+|-) Infinity divided by 1 and no precision given" do
+      @infinity_minus.div(@one).nan?.should == true
+      @infinity.div(@one).nan?.should == true
+      @infinity_minus.div(@one_minus).nan?.should == true
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises ZeroDivisionError if divided by zero and no precision given" do
+      lambda { @one.div(@zero) }.should raise_error(ZeroDivisionError)
+      lambda { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)
+      lambda { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+
+      lambda { @zero.div(@zero) }.should raise_error(ZeroDivisionError)
+      lambda { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)
+      lambda { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+    end
+
+    it "returns NaN if zero is divided by zero" do
+      @zero.div(@zero, 0).nan?.should == true
+      @zero_minus.div(@zero_plus, 0).nan?.should == true
+      @zero_plus.div(@zero_minus, 0).nan?.should == true
+
+      @zero.div(@zero, 10).nan?.should == true
+      @zero_minus.div(@zero_plus, 10).nan?.should == true
+      @zero_plus.div(@zero_minus, 10).nan?.should == true
+    end
+
+    it "raises FloatDomainError if (+|-) Infinity divided by 1 and no precision given" do
+      lambda { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)
+      lambda { @infinity.div(@one) }.should raise_error(FloatDomainError)
+      lambda { @infinity_minus.div(@one_minus) }.should raise_error(FloatDomainError)
+    end
+  end
+
+  it "returns (+|-)Infinity if (+|-)Infinity by 1 and precision given" do
+    @infinity_minus.div(@one, 0).should == @infinity_minus
+    @infinity.div(@one, 0).should == @infinity
+    @infinity_minus.div(@one_minus, 0).should == @infinity
+  end
+
+  it "returns NaN if Infinity / ((+|-) Infinity)" do
+    @infinity.div(@infinity_minus, 100000).nan?.should == true
+    @infinity_minus.div(@infinity, 1).nan?.should == true
+  end
+
+
+end

data/spec/divide_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/quo', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#/" do
+  it_behaves_like :bigdecimal_quo, :/, []
+end

data/spec/divmod_spec.rb

@@ -0,0 +1,233 @@
+require File.expand_path('../shared/modulo', __FILE__)
+require 'bigdecimal'
+
+module DivmodSpecs
+  def self.check_both_nan(array)
+    array.length.should == 2
+    array[0].nan?.should == true
+    array[1].nan?.should == true
+  end
+  def self.check_both_bigdecimal(array)
+    array.length.should == 2
+    array[0].kind_of?(BigDecimal).should == true
+    array[1].kind_of?(BigDecimal).should == true
+  end
+end
+
+# TODO: figure out a way to do the shared specs with helpers instead
+# of spec'ing a method that does not really exist
+describe "BigDecimal#mod_part_of_divmod" do
+  # BigDecimal#divmod[1] behaves exactly like #modulo
+  before :all do
+    class BigDecimal
+      def mod_part_of_divmod(arg)
+        divmod(arg)[1]
+      end
+    end
+  end
+
+  after :all do
+    class BigDecimal
+      undef mod_part_of_divmod
+    end
+  end
+
+  it_behaves_like :bigdecimal_modulo, :mod_part_of_divmod
+
+  ruby_version_is "" ... "1.9" do
+    it "does NOT raise ZeroDivisionError if other is zero" do
+      bd6543 = BigDecimal.new("6543.21")
+      bd5667 = BigDecimal.new("5667.19")
+      a = BigDecimal("1.0000000000000000000000000000000000000000005")
+      b = BigDecimal("1.00000000000000000000000000000000000000000005")
+
+      bd5667.send(@method, 0).nan?.should == true
+      bd5667.send(@method, BigDecimal("0")).nan?.should == true
+      @zero.send(@method, @zero).nan?.should == true
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises ZeroDivisionError if other is zero" do
+      bd6543 = BigDecimal.new("6543.21")
+      bd5667 = BigDecimal.new("5667.19")
+      a = BigDecimal("1.0000000000000000000000000000000000000000005")
+      b = BigDecimal("1.00000000000000000000000000000000000000000005")
+
+      lambda { bd5667.send(@method, 0) }.should raise_error(ZeroDivisionError)
+      lambda { bd5667.send(@method, BigDecimal("0")) }.should raise_error(ZeroDivisionError)
+      lambda { @zero.send(@method, @zero) }.should raise_error(ZeroDivisionError)
+    end
+  end
+end
+
+describe "BigDecimal#divmod" do
+
+  before(:each) do
+    @a = BigDecimal("42.00000000000000000001")
+
+    @zero = BigDecimal("0")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = BigDecimal("-0")
+
+    @one = BigDecimal("1")
+    @mixed = BigDecimal("1.23456789")
+    @pos_int = BigDecimal("2E5555")
+    @neg_int = BigDecimal("-2E5555")
+    @pos_frac = BigDecimal("2E-9999")
+    @neg_frac = BigDecimal("-2E-9999")
+    @nan = BigDecimal("NaN")
+    @infinity = BigDecimal("Infinity")
+    @infinity_minus = BigDecimal("-Infinity")
+    @one_minus = BigDecimal("-1")
+    @frac_1 = BigDecimal("1E-99999")
+    @frac_2 = BigDecimal("0.9E-99999")
+
+    @special_vals = [@infinity, @infinity_minus, @nan]
+    @regular_vals = [
+      @one, @mixed, @pos_int, @neg_int, @pos_frac,
+      @neg_frac, @one_minus, @frac_1, @frac_2]
+    @zeroes = [@zero, @zero_pos, @zero_neg]
+  end
+
+  it "divides value, returns an array" do
+    res = @a.divmod(5)
+    res.kind_of?(Array).should == true
+  end
+
+  it "array contains quotient and modulus as BigDecimal" do
+    res = @a.divmod(5)
+    DivmodSpecs::check_both_bigdecimal(res)
+    res[0].should == BigDecimal('0.8E1')
+    res[1].should == BigDecimal('2.00000000000000000001')
+
+    BigDecimal('1').divmod(BigDecimal('2')).should == [0, 1]
+    BigDecimal('2').divmod(BigDecimal('1')).should == [2, 0]
+
+    BigDecimal('1').divmod(BigDecimal('-2')).should == [-1, -1]
+    BigDecimal('2').divmod(BigDecimal('-1')).should == [-2, 0]
+
+    BigDecimal('-1').divmod(BigDecimal('2')).should == [-1, 1]
+    BigDecimal('-2').divmod(BigDecimal('1')).should == [-2, 0]
+  end
+
+  it "Can be reversed with * and +" do
+    # Example taken from BigDecimal documentation
+    a = BigDecimal.new("42")
+    b = BigDecimal.new("9")
+    q, m = a.divmod(b)
+    c = q * b + m
+    a.should == c
+
+    values = [@one, @one_minus, BigDecimal('2'), BigDecimal('-2'),
+      BigDecimal('5'), BigDecimal('-5'), BigDecimal('10'), BigDecimal('-10'),
+      BigDecimal('20'), BigDecimal('-20'), BigDecimal('100'), BigDecimal('-100'),
+      BigDecimal('1.23456789E10'), BigDecimal('-1.23456789E10')
+    ]
+
+    # TODO: file MRI bug:
+    # BigDecimal('1').divmod(BigDecimal('3E-9'))[0] #=> 0.3E9,
+    # but really should be 0.333333333E9
+    ruby_bug "#206", "1.8" do #MRI's precision is very low in some cases
+      values << BigDecimal('1E-10')
+      values << BigDecimal('-1E-10')
+      values << BigDecimal('2E55')
+      values << BigDecimal('-2E55')
+      values << BigDecimal('2E-5555')
+      values << BigDecimal('-2E-5555')
+
+
+      values_and_zeroes = values + @zeroes
+      values_and_zeroes.each do |val1|
+        values.each do |val2|
+          res = val1.divmod(val2)
+          DivmodSpecs::check_both_bigdecimal(res)
+          res[0].should == ((val1/val2).floor)
+          res[1].should == (val1 - res[0] * val2)
+        end
+      end
+    end
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "properly handles special values" do
+      values = @special_vals + @zeroes
+      values.each do |val1|
+        values.each do |val2|
+          DivmodSpecs::check_both_nan(val1.divmod(val2))
+        end
+      end
+
+      @special_vals.each do |val1|
+        @regular_vals.each do |val2|
+          DivmodSpecs::check_both_nan(val1.divmod(val2))
+        end
+      end
+
+      @regular_vals.each do |val1|
+        @special_vals.each do |val2|
+          DivmodSpecs::check_both_nan(val1.divmod(val2))
+        end
+      end
+    end
+
+    it "returns an array of two NaNs if the argument is zero" do
+      values = @regular_vals + @special_vals
+      values.each do |val1|
+        @zeroes.each do |val2|
+          DivmodSpecs::check_both_nan(val1.divmod(val2))
+        end
+      end
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "returns an array of two NaNs if NaN is involved" do
+      (@special_vals + @regular_vals + @zeroes).each do |val|
+        DivmodSpecs::check_both_nan(val.divmod(@nan))
+        DivmodSpecs::check_both_nan(@nan.divmod(val))
+      end
+    end
+
+    it "raises ZeroDivisionError if the divisor is zero" do
+      (@special_vals + @regular_vals + @zeroes - [@nan]).each do |val|
+        @zeroes.each do |zero|
+          lambda { val.divmod(zero) }.should raise_error(ZeroDivisionError)
+        end
+      end
+    end
+
+    it "returns an array of Infinity and NaN if the dividend is Infinity" do
+      @regular_vals.each do |val|
+        array = @infinity.divmod(val)
+        array.length.should == 2
+        array[0].infinite?.should == (val > 0 ? 1 : -1)
+        array[1].nan?.should == true
+      end
+    end
+
+    it "returns an array of zero and the dividend if the divisor is Infinity" do
+      @regular_vals.each do |val|
+        array = val.divmod(@infinity)
+        array.length.should == 2
+        array[0].should == @zero
+        array[1].should == val
+      end
+    end
+
+    it "returns an array of two zero if the diviend is zero" do
+      @zeroes.each do |zero|
+        @regular_vals.each do |val|
+          zero.divmod(val).should == [@zero, @zero]
+        end
+      end
+    end
+  end
+
+  it "raises TypeError if the argument cannot be coerced to BigDecimal" do
+    lambda {
+      @one.divmod('1')
+    }.should raise_error(TypeError)
+  end
+
+end