ruby-mpfr 0.0.2 → 0.0.4

data/ext/mpfr_matrix/mpfr/ruby_mpfr_matrix.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_GMP_MATRIX
+#define RUBY_GMP_MATRIX
+
+#include "func_mpfr_matrix.h"
+
+VALUE r_mpfr_matrix, r_mpfr_square_matrix, r_mpfr_col_vector, r_mpfr_row_vector, r_mpfr_vector_module;
+
+void r_mpfr_matrix_free(void *ptr);
+
+void r_mpfr_matrix_suitable_matrix_init (VALUE *other, MPFRMatrix **ptr_other, int row, int column);
+VALUE r_mpfr_matrix_robj(MPFRMatrix *x);
+
+#endif

data/lib/mpfr/matrix.rb

@@ -0,0 +1,145 @@
+require 'mpfr/matrix.so'
+
+class MPFR
+  class Matrix
+    def str_ary2_2(format)
+      ary = str_ary(format)
+      tmp = []
+      (0...row_size).each { tmp << [] }
+      i = 0
+      while i < size
+        for j in 0...row_size
+          tmp[j] << ary[i + j]
+        end
+        i += row_size
+      end
+      tmp
+    end
+    
+    def str_ary3(format)
+      ary = str_ary(format)
+      tmp = []
+      i = 0
+      while i < size
+        tmp << ary[i...(i + row_size)]
+        i += row_size
+      end
+      tmp
+    end
+    
+    def inspect
+      tmp = str_ary2("%.Re")
+      tmp.map!{ |a| "['" + a.join("', '") + "']" }
+      sprintf("#<%s:%x, [%s]>", self.class, __id__, tmp.join(', '))
+    end
+    
+    def pretty_print(pp)
+      ary = str_ary2("%.Re")
+      pp.object_group(self) do
+        pp.text(sprintf(':%x, ', __id__))
+        pp.breakable
+        pp.text("[")
+        pp.nest(1) do
+          for j in 0...row_size
+            pp.breakable if j > 0
+            pp.text(%|["#{ary[j][0]}"|)
+            pp.nest(1) do
+              for i in 1...column_size
+                pp.comma_breakable
+                pp.text(%|"#{ary[j][i]}"|)
+              end
+            end
+            pp.text("]")
+            pp.comma_breakable if j < row_size - 1
+          end
+          pp.text("]")
+        end
+      end
+    end
+    
+    def to_s(f = "%.Ff", delimiter = ' ')
+      str_ary(f).join(delimiter)
+    end
+
+    def self.create(a)
+      case a
+      when MPFR::Vector
+        if self === a
+          a.dup
+        else
+          self.new(a.to_a)
+        end
+      when MPFR::Matrix
+        if a.column_size == a.row_size
+          if MPFR::SquareMatrix === a
+            a.dup
+          else
+            MPFR::SquareMatrix.new(a.to_a)
+          end
+        else
+          a.dup
+        end
+      when Array
+        if Array == a[0] && a.size == a[0].size
+          MPFR::SquareMatrix.new(a)
+        else
+          self.new(a)
+        end
+      else
+        self.new(a)
+      end
+
+    end
+    
+    # ary is two-dimensional Array.
+    def self.suitable_matrix_from_ary(ary)
+      if ary.size == 1
+        RowVector.new(ary[0])
+      elsif ary[0].size == 1
+        ColumnVector.new(ary.inject([]){ |res, val| res << val[0] })
+      elsif ary[0].size == ary.size
+        SquareMatrix.new(ary)
+      else
+        Matrix.new(ary)
+      end
+    end
+
+  end
+
+  module Vector
+    def inspect
+      sprintf("#<%s:%x, ['%s']>", self.class, __id__, str_ary("%.Re").join("', '"))
+    end
+
+    def pretty_print(pp)
+      ary = str_ary("%.Re")
+      pp.object_group(self) do
+        pp.text(sprintf(':%x, ', __id__))
+        pp.breakable
+        pp.text(%|["#{ary[0]}"|)
+        pp.nest(1) do
+          for i in 1...dim
+            pp.comma_breakable
+            pp.text(%|"#{ary[i]}"|)
+          end
+        end
+        pp.text("]")
+      end
+    end
+
+    def to_s(format = "%.Re", delimiter = ' ')
+      str_ary(format).join(delimiter)
+    end
+
+    def self.inner_product(a, b)
+      a.inner_product(b)
+    end
+
+    def self.distance(a, b)
+      a.distance_from(b)
+    end
+
+  end
+
+end
+

data/lib/mpfr/version.rb

@@ -0,0 +1,3 @@
+module MPFR
+  VERSION = '0.0.4'
+end

data/ruby-mpfr.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby-mpfr}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Takayuki YAMAGUCHI"]
+  s.date = %q{2009-12-17}
+  s.description = %q{ruby-mpfr is library to use MPFR[http://www.mpfr.org/] which is a C library for
+multiple-precision floating-point computations.}
+  s.email = ["d@ytak.info"]
+  s.extensions = ["ext/mpfr/extconf.rb", "ext/mpfr_matrix/mpfr/extconf.rb"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc"]
+  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "ext/mpfr/extconf.rb", "ext/mpfr/ruby_mpfr.c", "ext/mpfr/ruby_mpfr.h", "ext/mpfr_matrix/mpfr/extconf.rb", "ext/mpfr_matrix/mpfr/func_mpfr_matrix.c", "ext/mpfr_matrix/mpfr/func_mpfr_matrix.h", "ext/mpfr_matrix/mpfr/ruby_mpfr.h", "ext/mpfr_matrix/mpfr/ruby_mpfr_matrix.c", "ext/mpfr_matrix/mpfr/ruby_mpfr_matrix.h", "lib/mpfr/matrix.rb", "lib/mpfr/version.rb", "ruby-mpfr.gemspec", "script/console", "script/destroy", "script/generate", "spec/mpfr/allocate_spec.rb", "spec/mpfr/arithmetic_spec.rb", "spec/mpfr/comparison_spec.rb", "spec/mpfr/constant_spec.rb", "spec/mpfr/conversion_spec.rb", "spec/mpfr/exception_spec.rb", "spec/mpfr/functions_spec.rb", "spec/mpfr/generate_number_modulue.rb", "spec/mpfr/precision_roundmode_spec.rb", "spec/mpfr/rounding_spec.rb", "spec/mpfr/set_value_spec.rb", "spec/mpfr/spec_helper.rb", "spec/mpfr/string_spec.rb", "spec/mpfr_matrix/generate_matrix_arguments.rb", "spec/mpfr_matrix/mpfr_matrix_alloc_spec.rb", "spec/mpfr_matrix/mpfr_matrix_arithmetic_spec.rb", "spec/mpfr_matrix/mpfr_matrix_set_element_spec.rb", "spec/mpfr_matrix/mpfr_matrix_string_spec.rb", "spec/mpfr_matrix/mpfr_square_matrix_spec.rb", "spec/mpfr_matrix/spec_helper.rb", "spec/spec.opts", "tasks/extconf.rake"]
+  s.homepage = %q{http://rubyforge.org/projects/ruby-mpfr/}
+  s.post_install_message = %q{PostInstall.txt}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{ruby-mpfr}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ruby-mpfr is library to use MPFR[http://www.mpfr.org/] which is a C library for multiple-precision floating-point computations.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 2.4.0"])
+    else
+      s.add_dependency(%q<hoe>, [">= 2.4.0"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 2.4.0"])
+  end
+end

data/spec/mpfr/allocate_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFR, 'when allocating objects from integer' do
+  it "should equal bignum" do
+    MPFR.set_default_prec(100)
+    num = 1
+    for i in 0..300
+      num *= 10
+      MPFR.new(num).should == num
+    end
+  end
+
+  it "should allocate from string" do
+    MPFR.set_default_prec(53)
+    for i in 0..1000
+      MPFR.new(i.to_s).should == i
+    end
+  end
+
+  it "should equal float" do
+    MPFR.set_default_prec(256)
+    error = MPFR.new('1.0e-10')
+    GenerateNumber.float(100) do |f|
+      MPFR.new(f).should == f
+    end
+  end
+
+  it "should duplicate" do
+    MPFR.set_default_prec(141)
+    for i in 0..1000
+      a = rand(10**10)
+      b = rand(10**50)
+      str = "#{a}.#{b}"
+      c = MPFR.new(str)
+      d = c.dup
+      c.should == d
+      c.object_id.should_not == d.object_id
+    end
+  end
+
+  it "should coerce" do
+    MPFR.set_default_prec(89)
+    a = MPFR.new('0.253242')
+    for i in 0..1000
+      b = MPFR.new(i)
+      c = a.coerce(i)[0]
+      b.should == c
+    end
+
+    a = MPFR.new('-13572834.923')
+    for i in 0..1000
+      str = (i + rand).to_s
+      b = MPFR.new(str)
+      c = a.coerce(str)[0]
+      b.should == c
+    end
+  end
+  
+end
+

data/spec/mpfr/arithmetic_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+MPFR.set_default_prec(256)
+
+def check_arithmetic_op(arg_ary, error, &block)
+  ruby_res = yield(*arg_ary)
+  mpfr_res = yield(*arg_ary.map{ |a| MPFR.new(a) })
+  mpfr_res = MPFR.new(mpfr_res) unless MPFR === mpfr_res
+  (ruby_res - mpfr_res).abs.should < error
+end
+
+describe MPFR, 'when calculating MPFR' do
+
+  it "should equal the result of built-in Numeric instance" do
+    error = 1.0e-10
+    arg = GenerateNumber.float_arguments(1, 1000)
+    arg << [0]
+    arg.each do |ary|
+      check_arithmetic_op(ary, error){ |a| a + 4 }
+      check_arithmetic_op(ary, error){ |a| 4 + a }
+      check_arithmetic_op(ary, error){ |a| a - 3 }
+      check_arithmetic_op(ary, error){ |a| 3 - a }
+      check_arithmetic_op(ary, error){ |a| a * 7 }
+      check_arithmetic_op(ary, error){ |a| 7 * a }
+      check_arithmetic_op(ary, error){ |a| a / 2 }
+      check_arithmetic_op(ary, error){ |a| (a.zero? ? 0 : 7 / a) }
+
+      check_arithmetic_op(ary, error){ |a| a + 4.0 }
+      check_arithmetic_op(ary, error){ |a| 4.0 + a }
+      check_arithmetic_op(ary, error){ |a| a - 3.0 }
+      check_arithmetic_op(ary, error){ |a| 3.0 - a }
+      check_arithmetic_op(ary, error){ |a| a * 7.0 }
+      check_arithmetic_op(ary, error){ |a| 7.0 * a }
+      check_arithmetic_op(ary, error){ |a| a / 2.0 }
+      check_arithmetic_op(ary, error){ |a| (a.zero? ? 0 : 7.0 / a) }
+    end
+  end
+
+  it "should equal the result of built-in Numeric instance" do
+    error = 1.0e-10
+    args = GenerateNumber.float_arguments(2, 1000)
+    args += [[0.0, 0.0], [0, -2.2], [0.0, 2.9], [1.1, 1000], [-23.1, 8.7]]
+    
+    args.each do |ary|
+      check_arithmetic_op(ary, error){ |a, b|  a + b }
+      check_arithmetic_op(ary, error){ |a, b|  a - b }
+      check_arithmetic_op(ary, error){ |a, b|  a * b }
+      check_arithmetic_op(ary, error){ |a, b|  (b.zero? ? 0 : a / b) }
+    end
+  end
+
+  it "should equal the result of built-in Numeric instance" do
+    error = 1.0e-10
+    args = GenerateNumber.float_arguments(3, 1000)
+    args += [[0.0, 0.0, 0.0], [0, 0.0, -2.2], [0.0, 2.9, 0.0], [1.1, 1000, 0.0], [-23.1, 8.7, 0.0]]
+
+    args.each do |ary|
+      check_arithmetic_op(ary, error){ |a, b, c|  a * a - b * b + c * c }
+      check_arithmetic_op(ary, error){ |a, b, c|  (c.zero? ? (a + b * (-0.3) - c) / 3 : (a + b * (-0.3) - c) / (3 * c)) }
+    end
+  end
+  
+end
+

data/spec/mpfr/comparison_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+MPFR.set_default_prec(256)
+
+def check_comparison(a, b)
+  ((a < b) == (MPFR.new(a) < MPFR.new(b))).should be_true
+  ((a > b) == (MPFR.new(a) > MPFR.new(b))).should be_true
+  ((a == b) == (MPFR.new(a) == MPFR.new(b))).should be_true
+end
+
+describe MPFR, "when comparing two numbers" do
+  it "should return the same result to built-in Numeric comparison" do
+    args = GenerateNumber.float_arguments(2, 1000)
+    args += [[0.0, 0.0], [-2.89, -2.89], [5.2, 2.9], [1000, 1000], [8.7, 8.7]]
+
+    args.each do |ary|
+      check_comparison(*ary)
+    end
+  end
+end
+

data/spec/mpfr/constant_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFR, "when calling constant of MPFR" do
+  it "should be defined" do
+    MPFR::MPFR_VERSION.should be_true
+    MPFR::MPFR_PATCHES.should be_true
+    MPFR::MPFR_VERSION2.should be_true
+    MPFR::MPFR_VERSION_MAJOR.should be_true
+    MPFR::MPFR_VERSION_MINOR.should be_true
+    MPFR::MPFR_VERSION_PATCHLEVEL.should be_true
+    MPFR::MPFR_VERSION_STRING.should be_true
+    MPFR::PREC_MAX.should be_true
+    MPFR::PREC_MIN.should be_true
+    MPFR::EMAX_DEFAULT.should be_true
+    MPFR::EMIN_DEFAULT.should be_true
+    MPFR::RNDN.should be_true
+    MPFR::RNDZ.should be_true
+    MPFR::RNDU.should be_true
+    MPFR::RNDD.should be_true
+    # MPFR::VERSION
+  end
+end
+

data/spec/mpfr/conversion_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+MPFR.set_default_prec(90)
+
+describe MPFR, 'when converting instance of other class' do
+  it "should be transformed to float" do
+    num = GenerateNumber.float(1000, 100) + [0.0]
+    num.each do |a|
+      b = MPFR.new(a).get_d(MPFR::RNDZ)
+      a.should == b
+    end
+  end
+end
+

data/spec/mpfr/exception_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFR, "when executing methods which are exception related functions" do
+  it "should get and set emin and emax" do
+    (emin = MPFR.get_emin).should be_a_kind_of Integer
+    (emax = MPFR.get_emax).should be_a_kind_of Integer
+    test_num = 1000
+    MPFR.set_emin(-test_num)
+    MPFR.get_emin.should == -test_num
+    MPFR.set_emax(test_num)
+    MPFR.get_emax.should == test_num
+    MPFR.set_emin(emin)
+    MPFR.set_emax(emax)
+    MPFR.get_emin_min.should be_a_kind_of Integer
+    MPFR.get_emin_max.should be_a_kind_of Integer
+    MPFR.get_emax_min.should be_a_kind_of Integer
+    MPFR.get_emax_max.should be_a_kind_of Integer
+  end
+end
+
+describe MPFR, "when executing exception of MPFR" do
+  it "should set exception" do
+    MPFR.set_underflow
+    MPFR.set_overflow
+    MPFR.set_nanflag
+    MPFR.set_inexflag
+    MPFR.set_erangeflag
+    MPFR.underflow_p.should be_true
+    MPFR.overflow_p.should be_true
+    MPFR.nanflag_p.should be_true
+    MPFR.inexflag_p.should be_true
+    MPFR.erangeflag_p.should be_true
+    MPFR.clear_underflow
+    MPFR.clear_overflow
+    MPFR.clear_nanflag
+    MPFR.clear_inexflag
+    MPFR.clear_erangeflag
+    MPFR.underflow_p.should be_false
+    MPFR.overflow_p.should be_false
+    MPFR.nanflag_p.should be_false
+    MPFR.inexflag_p.should be_false
+    MPFR.erangeflag_p.should be_false
+
+    MPFR.set_underflow
+    MPFR.set_overflow
+    MPFR.set_nanflag
+    MPFR.set_inexflag
+    MPFR.set_erangeflag
+    MPFR.clear_flags
+    MPFR.underflow_p.should be_false
+    MPFR.overflow_p.should be_false
+    MPFR.nanflag_p.should be_false
+    MPFR.inexflag_p.should be_false
+    MPFR.erangeflag_p.should be_false
+  end
+end
+
+# Need to spec for the following methods.
+# check_range
+# subnormalize

data/spec/mpfr/functions_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+MPFR.set_default_prec(256)
+
+describe MPFR, 'when executing mathematical functions' do
+  it "should calculate basic functions" do
+    error = MPFR.new('1.0e-10')
+    a = MPFR::Math.const_pi
+    (MPFR.new(Math::PI) - a).abs.should < error
+    (MPFR::Math.sin(a) - MPFR.new('0')).abs.should < error
+    (MPFR::Math.cos(a) - MPFR.new('-1')).abs.should < error
+    a = MPFR.new(Math::PI/4.0)
+    (MPFR::Math.sin(a) - MPFR.new(Math.sqrt(2.0)/2.0)).abs.should < error
+    (MPFR::Math.cos(a) - MPFR.new(Math.sqrt(2.0)/2.0)).abs.should < error
+    (MPFR::Math.tan(a) - MPFR.new(1)).abs.should < error
+
+    (MPFR::Math.atan(MPFR.new(1) / MPFR::Math.sqrt('3')) - MPFR::Math.const_pi / MPFR.new(6)).abs.should < error
+
+    a = MPFR::Math.exp(1)
+    (Math::E - a).abs.should < error
+    (MPFR.new(1) - MPFR::Math.log(a)).abs.should < error
+  end
+end
+
+

data/spec/mpfr/generate_number_modulue.rb

@@ -0,0 +1,44 @@
+module GenerateNumber
+
+  def self.float_arguments(size, number, max = 100)
+    ret = Array.new(number){ |j| Array.new(size){ |i| rand(max) - rand } }
+    for i in 0...(ret.size)
+      case i % 4
+      when 1
+        ret[i].map!{ |a| -a }
+      when 2, 3
+        ret[i].map!{ |a| (rand > 0.5 ? -a : a) }
+      end
+    end
+    ret
+  end
+
+  def self.float(num, max = 100, &block)
+    if block_given?
+      for i in 0...num
+        a = rand(max) - rand
+        a = -a if rand > 0.5
+        yield(a)
+      end
+    else
+      ary = Array.new(num){ |i| rand(max) - rand }
+      ary.map!{ |a| (rand > 0.5 ? -a : a) }
+    end
+  end
+
+  def self.string(number)
+    prec = MPFR.get_default_prec
+    max = 2 ** prec
+    Array.new(number) do |i|
+      sign = ((rand > 0.5 ? '-' : ''))
+      "#{sign}#{rand(max)}.#{rand(max)}"
+    end
+  end
+  
+  def self.mpfr_args(number)
+    ret = self.string(number)
+    ret.map!{ |a| MPFR.new(a) }
+  end
+  
+
+end

data/spec/mpfr/precision_roundmode_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+def check_rnd(a)
+  MPFR.new(a).should == MPFR.new(a, MPFR.get_default_rounding_mode)
+  n = MPFR.new(a, MPFR::RNDN)
+  z = MPFR.new(a, MPFR::RNDZ)
+  u = MPFR.new(a, MPFR::RNDU)
+  d = MPFR.new(a, MPFR::RNDD)
+  (n > 0 ? d : u).should == z
+  [(a - z).abs, (a - u).abs, (a - d).abs].min.should >= (a - n).abs
+  (d <= u && (n == z || n == u || n == d)).should be_true
+end
+
+def check_set_rnd(rnd1, rnd2)
+  MPFR.set_default_rounding_mode(rnd1)
+  MPFR.get_default_rounding_mode.should == rnd1
+  MPFR.set_default_rounding_mode(rnd2)
+  MPFR.get_default_rounding_mode.should_not == rnd1
+  MPFR.get_default_rounding_mode.should == rnd2
+end
+
+describe MPFR, 'when getting rounding mode' do
+  it "should return rounding mode" do
+    args = GenerateNumber.float(100)
+    args += [Math::PI, -Math::PI, Math::E, -Math::E, 0, 10, 27, -9, -293578]
+    args.each{ |a| check_rnd(a) }
+    [MPFR::RNDN, MPFR::RNDZ, MPFR::RNDU, MPFR::RNDD].each{ |rnd| args.each{ |a| check_rnd(a) } }
+  end
+
+  it "should be set rounding mode" do
+    rnds = [MPFR::RNDN, MPFR::RNDZ, MPFR::RNDU, MPFR::RNDD]
+    for i in 0...rnds.size
+      for j in (i+1)...rnds.size
+        check_set_rnd(rnds[i], rnds[j])
+      end
+    end
+  end
+end
+
+def check_set_prec(prec)
+  MPFR.set_default_prec(prec)
+  MPFR.get_default_prec.should == prec
+  a = MPFR.new(rand(10000) - rand)
+  MPFR.get_default_prec.should == a.get_prec
+  prec2 = prec / 2
+  a.set_prec(prec2)
+  a.nan?.should be_true
+  MPFR.get_default_prec.should_not == a.get_prec
+  prec2.should == a.get_prec
+  b = MPFR.new(rand(10000) - rand)
+  prec3 = prec * 3
+  MPFR.set_default_prec(prec3)
+  c = MPFR.new(rand(10000) - rand)
+  prec3.should == c.get_prec
+  c.get_prec.should_not == b.get_prec
+end
+
+describe MPFR, 'when setting precision' do
+  it "should be set precision" do
+    for i in 1...1000
+      check_set_prec(20 + rand(i))
+    end  
+  end
+end
+

data/spec/mpfr/rounding_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFR, "when rounding number by prec_round" do
+  before(:all) do
+    MPFR.set_default_prec(200)
+    @prec = 100
+    @args = GenerateNumber.float(1000).map{ |a| MPFR.new(a.to_s) }
+  end
+
+  it "should be rounded up" do
+    @args.each do |a|
+      a.prec_round(MPFR::RNDU, @prec).should >= a
+    end
+  end
+
+  it "should be rounded down" do
+    @args.each do |a|
+      a.prec_round(MPFR::RNDD, @prec).should <= a
+    end
+  end
+
+  it "should be rounded to zero" do
+    @args.each do |a|
+      if a > 0
+        a.prec_round(MPFR::RNDZ, @prec).should <= a
+      else
+        a.prec_round(MPFR::RNDZ, @prec).should >= a 
+      end
+    end
+  end
+
+  it "should be rounded to near number" do
+    @args.each do |a|
+      min = [(a - a.prec_round(MPFR::RNDU, @prec)).abs, (a - a.prec_round(MPFR::RNDD, @prec)).abs].min
+      (a - a.prec_round(MPFR::RNDN, @prec)).abs.should eql min
+    end
+  end
+
+  it "should be rounded by prec_round!" do
+    @args.each do |a|
+      [MPFR::RNDU, MPFR::RNDD, MPFR::RNDN, MPFR::RNDZ].each do |rnd|
+        b = a.dup
+        old_object_id = b.object_id
+        b.prec_round!(rnd, @prec)
+        b.should eql a.prec_round(rnd, @prec)
+        b.object_id.should eql old_object_id
+      end
+    end
+  end
+  
+end