rubysl-bigdecimal 1.0.0

data/lib/bigdecimal/sample/linear.rb

@@ -0,0 +1,71 @@
+#!/usr/local/bin/ruby
+
+#
+# linear.rb
+#
+# Solves linear equation system(A*x = b) by LU decomposition method.
+#  where  A is a coefficient matrix,x is an answer vector,b is a constant vector.
+#
+# USAGE:
+#   ruby linear.rb [input file solved]
+#
+
+require "bigdecimal"
+require "bigdecimal/ludcmp"
+
+#
+# NOTE:
+#   Change following BigDecimal::limit() if needed.
+BigDecimal::limit(100)
+#
+
+include LUSolve
+def rd_order(na)
+   printf("Number of equations ?") if(na <= 0)
+   n = ARGF.gets().to_i
+end
+
+na   = ARGV.size
+zero = BigDecimal::new("0.0")
+one  = BigDecimal::new("1.0")
+
+while (n=rd_order(na))>0
+  a = []
+  as= []
+  b = []
+  if na <= 0
+     # Read data from console.
+     printf("\nEnter coefficient matrix element A[i,j]\n");
+     for i in 0...n do
+       for j in 0...n do
+         printf("A[%d,%d]? ",i,j); s = ARGF.gets
+         a  << BigDecimal::new(s);
+         as << BigDecimal::new(s);
+       end
+       printf("Contatant vector element b[%d] ? ",i); b << BigDecimal::new(ARGF.gets);
+     end
+  else
+     # Read data from specified file.
+     printf("Coefficient matrix and constant vector.\n");
+     for i in 0...n do
+       s = ARGF.gets
+       printf("%d) %s",i,s)
+       s = s.split
+       for j in 0...n do
+         a  << BigDecimal::new(s[j]);
+         as << BigDecimal::new(s[j]);
+       end
+       b << BigDecimal::new(s[n]);
+     end
+  end
+  x = lusolve(a,b,ludecomp(a,n,zero,one),zero)
+  printf("Answer(x[i] & (A*x-b)[i]) follows\n")
+  for i in 0...n do
+     printf("x[%d]=%s ",i,x[i].to_s)
+     s = zero
+     for j in 0...n do
+       s = s + as[i*n+j]*x[j]
+     end
+     printf(" & %s\n",(s-b[i]).to_s)
+  end
+end

data/lib/bigdecimal/sample/nlsolve.rb

@@ -0,0 +1,38 @@
+#!/usr/local/bin/ruby
+
+#
+# nlsolve.rb
+# An example for solving nonlinear algebraic equation system.
+#
+
+require "bigdecimal"
+require "bigdecimal/newton"
+include Newton
+
+class Function
+  def initialize()
+    @zero = BigDecimal::new("0.0")
+    @one  = BigDecimal::new("1.0")
+    @two  = BigDecimal::new("2.0")
+    @ten  = BigDecimal::new("10.0")
+    @eps  = BigDecimal::new("1.0e-16")
+  end
+  def zero;@zero;end
+  def one ;@one ;end
+  def two ;@two ;end
+  def ten ;@ten ;end
+  def eps ;@eps ;end
+  def values(x) # <= defines functions solved
+    f = []
+    f1 = x[0]*x[0] + x[1]*x[1] - @two # f1 = x**2 + y**2 - 2 => 0
+    f2 = x[0] - x[1]                  # f2 = x    - y        => 0
+    f <<= f1
+    f <<= f2
+    f
+  end
+end
+ f = BigDecimal::limit(100)
+ f = Function.new
+ x = [f.zero,f.zero]      # Initial values
+ n = nlsolve(f,x)
+ p x

data/lib/bigdecimal/sample/pi.rb

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby
+
+#
+# pi.rb
+#
+# Calculates 3.1415.... (the number of times that a circle's diameter
+# will fit around the circle) using J. Machin's formula.
+#
+
+require "bigdecimal"
+require "bigdecimal/math.rb"
+
+include BigMath
+
+if ARGV.size == 1
+    print "PI("+ARGV[0]+"):\n"
+    p PI(ARGV[0].to_i)
+else
+    print "TRY: ruby pi.rb 1000 \n"
+end

data/lib/bigdecimal/util.rb

@@ -0,0 +1,65 @@
+#
+# BigDecimal utility library.
+#
+# To use these functions, require 'bigdecimal/util'
+#
+# The following methods are provided to convert other types to BigDecimals:
+#
+#   String#to_d -> BigDecimal
+#   Float#to_d -> BigDecimal
+#   Rational#to_d -> BigDecimal
+#
+# The following method is provided to convert BigDecimals to other types:
+#
+#   BigDecimal#to_r -> Rational
+#
+# ----------------------------------------------------------------------
+#
+class Float < Numeric
+  def to_d
+    BigDecimal(self.to_s)
+  end
+end
+
+class String
+  def to_d
+    BigDecimal(self)
+  end
+end
+
+class BigDecimal < Numeric
+  # Converts a BigDecimal to a String of the form "nnnnnn.mmm".
+  # This method is deprecated; use BigDecimal#to_s("F") instead.
+  def to_digits
+     if self.nan? || self.infinite? || self.zero?
+        self.to_s
+     else
+       i       = self.to_i.to_s
+       s,f,y,z = self.frac.split
+       i + "." + ("0"*(-z)) + f
+     end
+  end
+
+  # Converts a BigDecimal to a Rational.
+  def to_r 
+     sign,digits,base,power = self.split
+     numerator = sign*digits.to_i
+     denomi_power = power - digits.size # base is always 10
+     if denomi_power < 0
+        Rational(numerator,base ** (-denomi_power))
+     else
+        Rational(numerator * (base ** denomi_power),1)
+     end
+  end
+end
+
+class Rational < Numeric
+  # Converts a Rational to a BigDecimal
+  def to_d(nFig=0)
+     num = self.numerator.to_s
+     if nFig<=0
+        nFig = BigDecimal.double_fig*2+1
+     end
+     BigDecimal.new(num).div(self.denominator,nFig)
+  end
+end

data/lib/rubysl/bigdecimal.rb

@@ -0,0 +1,2 @@
+require "bigdecimal/bigdecimal"
+require "rubysl/bigdecimal/version"

data/lib/rubysl/bigdecimal/version.rb

@@ -0,0 +1,5 @@
+module RubySL
+  module BigDecimal
+    VERSION = "1.0.0"
+  end
+end

data/rubysl-bigdecimal.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+require './lib/rubysl/bigdecimal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubysl-bigdecimal"
+  spec.version       = RubySL::BigDecimal::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Ruby standard library bigdecimal.}
+  spec.summary       = %q{Ruby standard library bigdecimal.}
+  spec.homepage      = "https://github.com/rubysl/rubysl-bigdecimal"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.extensions    = ["ext/rubysl/bigdecimal/extconf.rb"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mspec", "~> 1.5"
+  spec.add_development_dependency "rubysl-prettyprint", "~> 1.0"
+end

data/spec/abs_spec.rb

@@ -0,0 +1,49 @@
+require 'bigdecimal'
+
+describe "BigDecimal#abs" do
+  before(:each) do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = BigDecimal("-0")
+    @two = BigDecimal("2")
+    @three = BigDecimal("3")
+    @mixed = BigDecimal("1.23456789")
+    @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 the absolute value" do
+    pos_int = BigDecimal("2E5555")
+    neg_int = BigDecimal("-2E5555")
+    pos_frac = BigDecimal("2E-9999")
+    neg_frac = BigDecimal("-2E-9999")
+
+    pos_int.abs.should == pos_int
+    neg_int.abs.should == pos_int
+    pos_frac.abs.should == pos_frac
+    neg_frac.abs.should == pos_frac
+    @one.abs.should == 1
+    @two.abs.should == 2
+    @three.abs.should == 3
+    @mixed.abs.should == @mixed
+    @one_minus.abs.should == @one
+  end
+
+  it "properly handles special values" do
+    @infinity.abs.should == @infinity
+    @infinity_minus.abs.should == @infinity
+    @nan.abs.nan?.should == true # have to do it this way, since == doesn't work on NaN
+    @zero.abs.should == 0
+    @zero.abs.sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @zero_pos.abs.should == 0
+    @zero_pos.abs.sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @zero_neg.abs.should == 0
+    @zero_neg.abs.sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+  end
+
+end

data/spec/add_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path('../fixtures/classes', __FILE__)
+
+require 'bigdecimal'
+
+describe "BigDecimal#add" do
+
+  before(:each) do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @two = BigDecimal("2")
+    @three = BigDecimal("3")
+    @ten = BigDecimal("10")
+    @eleven = BigDecimal("11")
+    @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")
+    @frac_3 = BigDecimal("12345E10")
+    @frac_4 = BigDecimal("98765E10")
+    @dot_ones = BigDecimal("0.1111111111")
+  end
+
+  it "returns a + b with given precision" do
+    # documentation states, that precision ist optional, but it ain't,
+    @two.add(@one, 1).should == @three
+    @one .add(@two, 1).should == @three
+    @one.add(@one_minus, 1).should == @zero
+    @ten.add(@one, 2).should == @eleven
+    @zero.add(@one, 1).should == @one
+    @frac_2.add(@frac_1, 10000).should == BigDecimal("1.9E-99999")
+    @frac_1.add(@frac_1, 10000).should == BigDecimal("2E-99999")
+    @frac_3.add(@frac_4, 0).should == BigDecimal("0.11111E16")
+    @frac_3.add(@frac_4, 1).should == BigDecimal("0.1E16")
+    @frac_3.add(@frac_4, 2).should == BigDecimal("0.11E16")
+    @frac_3.add(@frac_4, 3).should == BigDecimal("0.111E16")
+    @frac_3.add(@frac_4, 4).should == BigDecimal("0.1111E16")
+    @frac_3.add(@frac_4, 5).should == BigDecimal("0.11111E16")
+    @frac_3.add(@frac_4, 6).should == BigDecimal("0.11111E16")
+  end
+
+  it "returns a + [Fixnum value] with given precision" do
+    (1..10).each {|precision|
+      @dot_ones.add(0, precision).should == BigDecimal("0." + "1" * precision)
+    }
+    BigDecimal("0.88").add(0, 1).should == BigDecimal("0.9")
+  end
+
+  it "returns a + [Bignum value] with given precision" do
+    bignum = 10000000000000000000
+    (1..20).each {|precision|
+      @dot_ones.add(bignum, precision).should == BigDecimal("0.1E20")
+    }
+    (21..30).each {|precision|
+      @dot_ones.add(bignum, precision).should == BigDecimal(
+        "0.10000000000000000000" + "1" * (precision - 20) + "E20")
+    }
+  end
+
+#  TODO:
+#  http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17374
+#
+#  This doesn't work on MRI and looks like a bug to me:
+#  one can use BigDecimal + Float, but not Bigdecimal.add(Float)
+#
+#  it "returns a + [Float value] with given precision" do
+#    (1..10).each {|precision|
+#      @dot_ones.add(0.0, precision).should == BigDecimal("0." + "1" * precision)
+#    }
+#
+#    BigDecimal("0.88").add(0.0, 1).should == BigDecimal("0.9")
+#  end
+
+  it "favors the precision specified in the second argument over the global limit" do
+    BigDecimalSpecs::with_limit(1) do
+      BigDecimal('0.888').add(@zero, 3).should == BigDecimal('0.888')
+    end
+
+    BigDecimalSpecs::with_limit(2) do
+      BigDecimal('0.888').add(@zero, 1).should == BigDecimal('0.9')
+    end
+  end
+
+  it "uses the current rounding mode if rounding is needed" do
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_UP) do
+      BigDecimal('0.111').add(@zero, 1).should == BigDecimal('0.2')
+      BigDecimal('-0.111').add(@zero, 1).should == BigDecimal('-0.2')
+    end
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_DOWN) do
+      BigDecimal('0.999').add(@zero, 1).should == BigDecimal('0.9')
+      BigDecimal('-0.999').add(@zero, 1).should == BigDecimal('-0.9')
+    end
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_HALF_UP) do
+      BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.9')
+      BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.9')
+    end
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_HALF_DOWN) do
+      BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.8')
+      BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.8')
+    end
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_HALF_EVEN) do
+      BigDecimal('0.75').add(@zero, 1).should == BigDecimal('0.8')
+      BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.8')
+      BigDecimal('-0.75').add(@zero, 1).should == BigDecimal('-0.8')
+      BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.8')
+    end
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_CEILING) do
+      BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.9')
+      BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.8')
+    end
+    BigDecimalSpecs::with_rounding(BigDecimal::ROUND_FLOOR) do
+      BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.8')
+      BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.9')
+    end
+  end
+
+  it "uses the default ROUND_HALF_UP rounding if it wasn't explicitly changed" do
+    BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.9')
+    BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.9')
+  end
+
+  it "returns NaN if NaN is involved" do
+    @one.add(@nan, 10000).nan?.should == true
+    @nan.add(@one, 1).nan?.should == true
+  end
+
+  it "returns Infinity or -Infinity if these are involved" do
+    @zero.add(@infinity, 1).should == @infinity
+    @frac_2.add(@infinity, 1).should == @infinity
+    @one_minus.add(@infinity, 1).should == @infinity
+    @two.add(@infinity, 1).should == @infinity
+
+    @zero.add(@infinity_minus, 1).should == @infinity_minus
+    @frac_2.add(@infinity_minus, 1).should == @infinity_minus
+    @one_minus.add(@infinity_minus, 1).should == @infinity_minus
+    @two.add(@infinity_minus, 1).should == @infinity_minus
+
+    @infinity.add(@zero, 1).should == @infinity
+    @infinity.add(@frac_2, 1).should == @infinity
+    @infinity.add(@one_minus, 1).should == @infinity
+    @infinity.add(@two, 1).should == @infinity
+
+    @infinity_minus.add(@zero, 1).should == @infinity_minus
+    @infinity_minus.add(@frac_2, 1).should == @infinity_minus
+    @infinity_minus.add(@one_minus, 1).should == @infinity_minus
+    @infinity_minus.add(@two, 1).should == @infinity_minus
+
+    @infinity.add(@infinity, 10000).should == @infinity
+    @infinity_minus.add(@infinity_minus, 10000).should == @infinity_minus
+  end
+
+  it "returns NaN if Infinity + (- Infinity)" do
+    @infinity.add(@infinity_minus, 10000).nan?.should == true
+    @infinity_minus.add(@infinity, 10000).nan?.should == true
+  end
+
+  it "raises TypeError when adds nil" do
+    lambda {
+      @one.add(nil, 10)
+    }.should raise_error(TypeError)
+    lambda {
+      @one.add(nil, 0)
+    }.should raise_error(TypeError)
+  end
+
+  it "raises TypeError when precision parameter is nil" do
+    lambda {
+      @one.add(@one, nil)
+    }.should raise_error(TypeError)
+  end
+
+  it "raises ArgumentError when precision parameter is negative" do
+    lambda {
+      @one.add(@one, -10)
+    }.should raise_error(ArgumentError)
+  end
+end