rubysl-bigdecimal 1.0.0

data/spec/shared/to_int.rb

@@ -0,0 +1,27 @@
+require 'bigdecimal'
+
+describe :bigdecimal_to_int , :shared => true do
+  ruby_version_is "" ... "1.9" do
+    ruby_bug "fixed_in_ruby_1_8_7@25799", "1.8.7.202" do
+      it "returns nil if BigDecimal is infinity or NaN" do
+        BigDecimal("Infinity").send(@method).should == nil
+        BigDecimal("NaN").send(@method).should == nil
+      end
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises FloatDomainError if BigDecimal is infinity or NaN" do
+      lambda { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
+      lambda { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
+    end
+  end
+
+  it "returns Integer or Bignum otherwise" do
+    BigDecimal("3E-20001").send(@method).should == 0
+    BigDecimal("2E4000").send(@method).should == 2 * 10 ** 4000
+    BigDecimal("2").send(@method).should == 2
+    BigDecimal("2E10").send(@method).should == 20000000000
+    BigDecimal("3.14159").send(@method).should == 3
+  end
+end

data/spec/sign_spec.rb

@@ -0,0 +1,46 @@
+require 'bigdecimal'
+
+describe "BigDecimal#sign" do
+
+  it "BigDecimal defines several constants for signs" do
+    # are these really correct?
+    BigDecimal::SIGN_POSITIVE_INFINITE.should == 3
+    BigDecimal::SIGN_NEGATIVE_INFINITE.should == -3
+    BigDecimal::SIGN_POSITIVE_ZERO.should == 1
+    BigDecimal::SIGN_NEGATIVE_ZERO.should == -1
+    BigDecimal::SIGN_POSITIVE_FINITE.should == 2
+    BigDecimal::SIGN_NEGATIVE_FINITE.should == -2
+  end
+
+  it "returns positive value if BigDecimal greater than 0" do
+    BigDecimal("1").sign.should  == BigDecimal::SIGN_POSITIVE_FINITE
+    BigDecimal("1E-20000000").sign.should == BigDecimal::SIGN_POSITIVE_FINITE
+    BigDecimal("1E200000000").sign.should == BigDecimal::SIGN_POSITIVE_FINITE
+    BigDecimal("Infinity").sign.should == BigDecimal::SIGN_POSITIVE_INFINITE
+  end
+
+  it "returns negative value if BigDecimal less than 0" do
+    BigDecimal("-1").sign.should == BigDecimal::SIGN_NEGATIVE_FINITE
+    BigDecimal("-1E-9990000").sign.should == BigDecimal::SIGN_NEGATIVE_FINITE
+    BigDecimal("-1E20000000").sign.should == BigDecimal::SIGN_NEGATIVE_FINITE
+    BigDecimal("-Infinity").sign.should == BigDecimal::SIGN_NEGATIVE_INFINITE
+  end
+
+  it "returns positive zero if BigDecimal equals positve zero" do
+    BigDecimal("0").sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    BigDecimal("0E-200000000").sign.should ==  BigDecimal::SIGN_POSITIVE_ZERO
+    BigDecimal("0E200000000").sign.should ==  BigDecimal::SIGN_POSITIVE_ZERO
+  end
+
+  it "returns negative zero if BigDecimal equals negative zero" do
+    BigDecimal("-0").sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+    BigDecimal("-0E-200000000").sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+    BigDecimal("-0E200000000").sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+  end
+
+  it "returns BigDecimal::SIGN_NaN if BigDecimal is NaN" do
+    BigDecimal("NaN").sign.should == BigDecimal::SIGN_NaN
+  end
+
+end
+

data/spec/split_spec.rb

@@ -0,0 +1,87 @@
+require 'bigdecimal'
+
+describe "BigDecimal#split" do
+
+  before(:each) do
+    @arr = BigDecimal("0.314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043E1").split
+    @arr_neg = BigDecimal("-0.314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043E1").split
+    @digits = "922337203685477580810101333333333333333333333333333"
+    @arr_big = BigDecimal("00#{@digits}000").split
+    @arr_big_neg = BigDecimal("-00#{@digits}000").split
+    @huge = BigDecimal('100000000000000000000000000000000000000000001E90000000').split
+
+    @infinity = BigDecimal("Infinity")
+    @infinity_neg = BigDecimal("-Infinity")
+    @nan = BigDecimal("NaN")
+    @zero = BigDecimal("0")
+    @zero_neg = BigDecimal("-0")
+  end
+
+  it "splits BigDecimal in an array with four values" do
+    @arr.size.should == 4
+  end
+
+  it "First value: 1 for numbers > 0" do
+    @arr[0].should == 1
+    @arr_big[0].should == 1
+    @zero.split[0].should == 1
+    @huge[0].should == 1
+    BigDecimal("+0").split[0].should == 1
+    BigDecimal("1E400").split[0].should == 1
+    @infinity.split[0].should == 1
+  end
+
+  it "First value: -1 for numbers < 0" do
+    @arr_neg[0].should == -1
+    @arr_big_neg[0].should == -1
+    @zero_neg.split[0].should == -1
+    BigDecimal("-1E400").split[0].should == -1
+    @infinity_neg.split[0].should == -1
+  end
+
+  it "First value: 0 if BigDecimal is NaN" do
+    BigDecimal("NaN").split[0].should == 0
+  end
+
+  it "Second value: a string with the significant digits" do
+    string = "314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043"
+    @arr[1].should == string
+    @arr_big[1].should == @digits
+    @arr_big_neg[1].should == @digits
+    @huge[1].should == "100000000000000000000000000000000000000000001"
+    @infinity.split[1].should == @infinity.to_s
+    @nan.split[1].should == @nan.to_s
+    @infinity_neg.split[1].should == @infinity.to_s
+    @zero.split[1].should == "0"
+    BigDecimal("-0").split[1].should == "0"
+  end
+
+  it "Third value: the base (currently always ten)" do
+   @arr[2].should == 10
+   @arr_neg[2].should == 10
+   @arr_big[2].should == 10
+   @arr_big_neg[2].should == 10
+   @huge[2].should == 10
+   @infinity.split[2].should == 10
+   @nan.split[2].should == 10
+   @infinity_neg.split[2].should == 10
+   @zero.split[2].should == 10
+   @zero_neg.split[2].should == 10
+  end
+
+  it "Fourth value: The exponent" do
+    @arr[3].should == 1
+    @arr_neg[3].should == 1
+    @arr_big[3].should == 54
+    @arr_big_neg[3].should == 54
+    @huge[3].should == 90000045
+    @infinity.split[3].should == 0
+    @nan.split[3].should == 0
+    @infinity_neg.split[3].should == 0
+    @zero.split[3].should == 0
+    @zero_neg.split[3].should == 0
+  end
+
+end
+
+

data/spec/sqrt_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path('../fixtures/classes', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#sqrt" do
+  before(:each) do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = BigDecimal("-0")
+    @two = BigDecimal("2.0")
+    @three = BigDecimal("3.0")
+    @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 square root of 2 with desired precision" do
+    string = "1.41421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157"
+    (1..99).each { |idx|
+      @two.sqrt(idx).should be_close(BigDecimal(string), BigDecimal("1E-#{idx-1}"))
+    }
+  end
+
+  it "returns square root of 3 with desired precision" do
+    sqrt_3 = "1.732050807568877293527446341505872366942805253810380628055806979451933016908800037081146186757248575"
+    (1..99).each { |idx|
+      @three.sqrt(idx).should be_close(BigDecimal(sqrt_3), BigDecimal("1E-#{idx-1}"))
+    }
+  end
+
+  it "returns square root of 121 with desired precision" do
+    BigDecimal('121').sqrt(5).should be_close(11, 0.00001)
+  end
+
+  it "returns square root of 0.9E-99999 with desired precision" do
+    @frac_2.sqrt(1).to_s.should == "0.3E-49999"
+  end
+
+  it "raises ArgumentError when no argument is given" do
+    lambda {
+      @one.sqrt
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises ArgumentError if a negative number is given" do
+    lambda {
+      @one.sqrt(-1)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises ArgumentError if 2 arguments are given" do
+    lambda {
+      @one.sqrt(1, 1)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises TypeError if nil is given" do
+    lambda {
+      @one.sqrt(nil)
+    }.should raise_error(TypeError)
+  end
+
+  it "raises TypeError if a string is given" do
+    lambda {
+      @one.sqrt("stuff")
+    }.should raise_error(TypeError)
+  end
+
+  it "raises TypeError if a plain Object is given" do
+    lambda {
+      @one.sqrt(Object.new)
+    }.should raise_error(TypeError)
+  end
+
+  it "returns 1 if precision is 0 or 1" do
+    @one.sqrt(1).should == 1
+    @one.sqrt(0).should == 1
+  end
+
+  it "raises FloatDomainError on negative values" do
+    lambda {
+      BigDecimal('-1').sqrt(10)
+    }.should raise_error(FloatDomainError)
+  end
+
+  it "returns positive infitinity for infinity" do
+    @infinity.sqrt(1).should == @infinity
+  end
+
+  it "raises FloatDomainError for negative infinity" do
+    lambda {
+      @infinity_minus.sqrt(1)
+    }.should raise_error(FloatDomainError)
+  end
+
+  it "raises FloatDomainError for NaN" do
+    lambda {
+      @nan.sqrt(1)
+    }.should raise_error(FloatDomainError)
+  end
+
+  it "returns 0 for 0, +0.0 and -0.0" do
+    @zero.sqrt(1).should == 0
+    @zero_pos.sqrt(1).should == 0
+    @zero_neg.sqrt(1).should == 0
+  end
+
+end

data/spec/sub_spec.rb

@@ -0,0 +1,52 @@
+require 'bigdecimal'
+
+describe "BigDecimal#sub" do
+
+  before(:each) do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @two = BigDecimal("2")
+    @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 given precision" do
+    # documentation states, that precision is optional
+    # but implementation raises ArgumentError if not given.
+
+    @two.sub(@one, 1).should == @one
+    @one.sub(@two, 1).should == @one_minus
+    @one.sub(@one_minus, 1).should == @two
+    @frac_2.sub(@frac_1, 1000000).should == BigDecimal("-0.1E-99999")
+    @frac_2.sub(@frac_1, 1).should == BigDecimal("-0.1E-99999")
+    # the above two examples puzzle me.
+    in_arow_one = BigDecimal("1.23456789")
+    in_arow_two = BigDecimal("1.2345678")
+    in_arow_one.sub(in_arow_two, 10).should == BigDecimal("0.9E-7")
+    @two.sub(@two,1).should == @zero
+    @frac_1.sub(@frac_1, 1000000).should == @zero
+  end
+
+  it "returns NaN if NaN is involved" do
+    @one.sub(@nan, 1).nan?.should == true
+    @nan.sub(@one, 1).nan?.should == true
+  end
+
+  it "returns NaN if both values are infinite with the same signs" do
+    @infinity.sub(@infinity, 1).nan?.should == true
+    @infinity_minus.sub(@infinity_minus, 1).nan?.should == true
+  end
+
+  it "returns Infinity or -Infinity if these are involved" do
+    @infinity.sub(@infinity_minus, 1).should == @infinity
+    @infinity_minus.sub(@infinity, 1).should == @infinity_minus
+    @zero.sub(@infinity, 1).should == @infinity_minus
+    @frac_2.sub( @infinity, 1).should == @infinity_minus
+    @two.sub(@infinity, 1).should == @infinity_minus
+  end
+
+end

data/spec/to_f_spec.rb

@@ -0,0 +1,54 @@
+require 'bigdecimal'
+
+describe "BigDecimal#to_f" do
+  before(:each) do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = 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")
+    @vals = [@one, @zero, @two, @three, @frac_1, @frac_2]
+    @spec_vals = [@zero_pos, @zero_neg, @nan, @infinity, @infinity_minus]
+  end
+
+  it "returns number of type float" do
+    BigDecimal("3.14159").to_f.should be_kind_of(Float)
+    @vals.each { |val| val.to_f.should be_kind_of(Float) }
+    @spec_vals.each { |val| val.to_f.should be_kind_of(Float) }
+  end
+
+  it "Floating point rounding occurs" do
+    bigdec = BigDecimal("3.141592653589793238462643383279502884197169399375")
+    bigdec.to_f.should be_close(3.14159265358979, TOLERANCE)
+    @one.to_f.should == 1.0
+    @two.to_f.should == 2.0
+    @three.to_f.should be_close(3.0, TOLERANCE)
+    @one_minus.to_f.should == -1.0
+
+    # regression test for [ruby-talk:338957]
+    BigDecimal("10.03").to_f.should == 10.03
+  end
+
+  it "properly handles special values" do
+    @zero.to_f.should == 0
+    @zero.to_f.to_s.should == "0.0"
+
+    @nan.to_f.nan?.should == true
+
+    @infinity.to_f.infinite?.should == 1
+    @infinity_minus.to_f.infinite?.should == -1
+  end
+
+  it "remembers negative zero when converted to float" do
+    @zero_neg.to_f.should == 0
+    @zero_neg.to_f.to_s.should == "-0.0"
+  end
+end
+

data/spec/to_i_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/to_int', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#to_i" do
+    it_behaves_like(:bigdecimal_to_int, :to_i)
+end

data/spec/to_int_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../shared/to_int', __FILE__)
+require 'bigdecimal'
+
+
+describe "BigDecimal#to_int" do
+  it_behaves_like(:bigdecimal_to_int, :to_int)
+end

data/spec/to_s_spec.rb

@@ -0,0 +1,71 @@
+require 'bigdecimal'
+
+describe "BigDecimal#to_s" do
+
+  before(:each) do
+    @bigdec_str = "3.14159265358979323846264338327950288419716939937"
+    @bigneg_str = "-3.1415926535897932384626433832795028841971693993"
+    @bigdec = BigDecimal(@bigdec_str)
+    @bigneg = BigDecimal(@bigneg_str)
+  end
+
+  it "return type is of class String" do
+    @bigdec.to_s.kind_of?(String).should == true
+    @bigneg.to_s.kind_of?(String).should == true
+  end
+
+  it "the default format looks like 0.xxxxEnn" do
+    @bigdec.to_s.should  =~ /^0\.[0-9]*E[0-9]*$/
+  end
+
+  it "takes an optional argument" do
+    lambda {@bigdec.to_s("F")}.should_not raise_error()
+  end
+
+  it "starts with + if + is supplied and value is positive" do
+    @bigdec.to_s("+").should =~ /^\+.*/
+    @bigneg.to_s("+").should_not =~ /^\+.*/
+  end
+
+  it "inserts a space every n chars, if integer n is supplied" do
+    str =\
+      "0.314 159 265 358 979 323 846 264 338 327 950 288 419 716 939 937E1"
+    @bigdec.to_s(3).should == str
+    str1 = '-123.45678 90123 45678 9'
+    BigDecimal.new("-123.45678901234567890").to_s('5F').should ==  str1
+    # trailing zeroes removed
+    BigDecimal.new("1.00000000000").to_s('1F').should == "1.0"
+    # 0 is treated as no spaces
+    BigDecimal.new("1.2345").to_s('0F').should == "1.2345"
+  end
+
+  it "can return a leading space for values > 0" do
+    @bigdec.to_s(" F").should =~ /\ .*/
+    @bigneg.to_s(" F").should_not =~ /\ .*/
+  end
+
+  it "removes trailing spaces in floating point notation" do
+    BigDecimal.new('-123.45678901234567890').to_s('F').should == "-123.4567890123456789"
+    BigDecimal.new('1.2500').to_s('F').should == "1.25"
+    BigDecimal.new('0000.00000').to_s('F').should == "0.0"
+    BigDecimal.new('-00.000010000').to_s('F').should == "-0.00001"
+    BigDecimal.new("5.00000E-2").to_s("F").should == "0.05"
+
+    BigDecimal.new("500000").to_s("F").should == "500000.0"
+    BigDecimal.new("5E2").to_s("F").should == "500.0"
+    BigDecimal.new("-5E100").to_s("F").should == "-5" + "0" * 100 + ".0"
+  end
+
+  it "can use engineering notation" do
+    @bigdec.to_s("E").should =~ /^0\.[0-9]*E[0-9]*$/
+  end
+
+  it "can use conventional floating point notation" do
+    @bigdec.to_s("F").should == @bigdec_str
+    @bigneg.to_s("F").should == @bigneg_str
+    str2 = "+123.45678901 23456789"
+    BigDecimal.new('123.45678901234567890').to_s('+8F').should == str2
+  end
+
+end
+