ruby-mpfi 0.0.2

data/ext/mpfi_matrix/mpfi/ruby_mpfi_matrix.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_MPFI_MATRIX
+#define RUBY_MPFI_MATRIX
+
+#include "func_mpfi_matrix.h"
+
+VALUE r_mpfi_matrix, r_mpfi_square_matrix, r_mpfi_col_vector, r_mpfi_row_vector, r_mpfi_vector_module;
+
+void r_mpfi_matrix_free(void *ptr);
+
+void r_mpfi_matrix_suitable_matrix_init (VALUE *other, MPFIMatrix **ptr_other, int row, int column);
+VALUE r_mpfi_matrix_robj(MPFIMatrix *x);
+
+#endif

data/ext/mpfi_matrix/mpfi/ruby_mpfr.h

@@ -0,0 +1,38 @@
+#ifndef _RUBY_MPFR_H_
+#define _RUBY_MPFR_H_
+
+#include <ruby.h>
+#include <mpfr.h>
+#include <stdio.h>
+
+typedef __mpfr_struct MPFR;
+
+VALUE r_mpfr_class, r_mpfr_math;
+
+#define r_mpfr_make_struct(ruby_var, c_var) { ruby_var = Data_Make_Struct(r_mpfr_class, MPFR, 0, r_mpfr_free, c_var); }
+#define r_mpfr_make_struct_init(ruby_var, c_var) { r_mpfr_make_struct(ruby_var, c_var); mpfr_init(c_var); }
+#define r_mpfr_make_struct_init2(ruby_var, c_var, prec) { r_mpfr_make_struct(ruby_var, c_var); mpfr_init2(c_var, prec); }
+#define r_mpfr_get_struct(c_var, ruby_var) { Data_Get_Struct(ruby_var, MPFR, c_var); }
+
+#define r_mpfr_temp_alloc(var) { var=ALLOC_N(MPFR, 1); }
+#define r_mpfr_temp_alloc_init(var) { r_mpfr_temp_alloc(var); mpfr_init(var); }
+#define r_mpfr_temp_alloc_init2(var, prec) { r_mpfr_temp_alloc(var); mpfr_init2(var, prec); }
+#define r_mpfr_temp_free(var) { mpfr_clear(var); free(var); }
+
+#define r_mpfr_check_number(c_val) { if(mpfr_number_p(c_val) == 0) rb_raise(rb_eArgError, "Not an ordinary number."); }
+#define r_mpfr_check_positive_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) <= 0) rb_raise(rb_eArgError, "Not a positive number."); }
+#define r_mpfr_check_non_negative_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) < 0) rb_raise(rb_eArgError, "Not a non negative number."); }
+#define r_mpfr_check_negative_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) >= 0) rb_raise(rb_eArgError, "Not a negative number."); }
+#define r_mpfr_check_non_positive_number(c_val) { if(mpfr_number_p(c_val) == 0 && mpfr_sgn(c_val) > 0) rb_raise(rb_eArgError, "Not a non positive number."); }
+
+void r_mpfr_free(void *ptr);
+VALUE r_mpfr_new_fr_obj(VALUE obj);
+void r_mpfr_set_robj(MPFR *ptr, VALUE obj, mp_rnd_t rnd);
+
+mp_rnd_t r_mpfr_rnd_from_value(VALUE rnd);
+mp_rnd_t r_mpfr_rnd_from_optional_argument(int min, int max, int argc, VALUE *argv);
+mp_rnd_t r_mpfr_prec_from_optional_argument(int min, int max, int argc, VALUE *argv);
+void r_mpfr_get_rnd_prec_from_optional_arguments(mp_rnd_t *rnd, mp_prec_t *prec, int min, int max, int argc, VALUE *argv);
+
+#endif /* _RUBY_MPFR_H_ */
+

data/ext/mpfi_matrix/mpfi/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/mpfi/matrix.rb

@@ -0,0 +1,188 @@
+require 'mpfi/matrix.so'
+
+class MPFI
+  class Matrix
+    def inspect
+      tmp = str_ary_for_inspect2
+      tmp.map!{ |a| "['" + a.join("', '") + "']"}
+      sprintf("#<%s:%x, [%s]>", self.class, __id__, tmp.join(', '))
+    end
+    
+    def pretty_print(pp)
+      ary = str_ary_for_inspect2
+      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("]")          
+          end
+          pp.text("]")
+        end
+      end
+    end
+    
+    def to_s(delimiter = ' ')
+      str_ary_for_inspect.join(delimiter)
+    end
+
+    def self.create(a)
+      case a
+      when MPFI::Vector
+        if self === a
+          a.dup
+        else
+          self.new(a.to_a)
+        end
+      when MPFI::Matrix
+        if a.column_size == a.row_size
+          if MPFI::SquareMatrix === a
+            a.dup
+          else
+            MPFI::SquareMatrix.new(a.to_a)
+          end
+        else
+          a.dup
+        end
+      when Array
+        if Array == a[0] && a.size == a[0].size
+          MPFI::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
+
+    def self.interval(ary)
+      if Array === ary && ary.all?{ |a| Array === a }
+        row = ary.size
+        column = ary[0].size
+        if ary.all?{ |a| a.size == column }
+          ret = self.new(row, column)
+          (0...row).each do |i|
+            (0...column).each do |j|
+              case ary[i][j]
+              when Array
+                ret[i, j] = MPFI.interval(*ary[i][j])
+              when String
+                ret[i, j] = MPFI.interval(*(ary[i][j].split))
+              when MPFI
+                ret[i, j] = ary[i][j]
+              else
+                raise ArgumentError, "Invalid class for argument"
+              end
+            end
+          end
+        else
+          ret = nil
+        end
+      end
+      ret
+    end
+    
+  end
+
+  module Vector
+    def inspect
+      sprintf("#<%s:%x, ['%s']>", self.class, __id__, str_ary_for_inspect.join("', '"))
+    end
+
+    def pretty_print(pp)
+      ary = str_ary_for_inspect
+      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(delimiter = ' ')
+      str_ary_for_inspect.join(delimiter)
+    end
+
+    def subdivision_by_size(size)
+      division = []
+      each { |el| division << el.subdivision((el.diam_abs / size).ceil) }
+      ary_size = division.inject(1) { |mul, a| mul * a.size }
+      ary = Array.new(ary_size) { Array.new }
+      num = ary_size
+      division.each do |div|
+        j = 0
+        repeat = ary_size / num
+        num = num / div.size
+        repeat.times do
+          div.size.times do |i|
+            num.times do
+              ary[j] << div[i]
+              j += 1
+            end
+          end
+        end
+      end
+      ary.map! { |a| self.class.new(a) }
+    end
+    
+    def self.inner_product(a, b)
+      a.inner_product(b)
+    end
+
+    def self.distance(a, b)
+      a.distance_from(b)
+    end
+
+  end
+
+  class ColumnVector
+    def self.interval(ary)
+      if Array === ary && ary.all?{ |a| Array === a }
+        self.new(ary.map { |a| MPFI.interval(*a) })
+      else
+        nil
+      end
+    end
+  end
+
+  class RowVector
+    def self.interval(ary)
+      if Array === ary && ary.all?{ |a| Array === a }
+        self.new(ary.map { |a| MPFI.interval(*a) })
+      else
+        nil
+      end
+    end
+  end
+  
+end
+

data/lib/mpfi/version.rb

@@ -0,0 +1,3 @@
+module MPFI
+  VERSION = '0.0.2'
+end

data/ruby-mpfi.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby-mpfi}
+  s.version = "0.0.2"
+
+  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{FIX (describe your package)}
+  s.email = ["d@ytak.info"]
+  s.extensions = ["ext/mpfi/extconf.rb", "ext/mpfi_complex/mpfi/extconf.rb", "ext/mpfi_matrix/mpfi/extconf.rb"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt"]
+  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "ext/mpfi/extconf.rb", "ext/mpfi/func_mpfi_extention.c", "ext/mpfi/func_mpfi_extention.h", "ext/mpfi/make_c_source.rb", "ext/mpfi/ruby_mpfi.c", "ext/mpfi/ruby_mpfi.h", "ext/mpfi/ruby_mpfr.h", "ext/mpfi/yasnippet_mpfi.el", "ext/mpfi_complex/mpfi/extconf.rb", "ext/mpfi_complex/mpfi/func_mpfi_extention.h", "ext/mpfi_complex/mpfi/func_ruby_mpfi_complex.c", "ext/mpfi_complex/mpfi/func_ruby_mpfi_complex.h", "ext/mpfi_complex/mpfi/ruby_mpfi.h", "ext/mpfi_complex/mpfi/ruby_mpfi_complex.c", "ext/mpfi_complex/mpfi/ruby_mpfi_complex.h", "ext/mpfi_complex/mpfi/ruby_mpfr.h", "ext/mpfi_matrix/mpfi/extconf.rb", "ext/mpfi_matrix/mpfi/func_mpfi_extention.h", "ext/mpfi_matrix/mpfi/func_mpfi_matrix.c", "ext/mpfi_matrix/mpfi/func_mpfi_matrix.h", "ext/mpfi_matrix/mpfi/func_mpfr_matrix.h", "ext/mpfi_matrix/mpfi/func_ruby_mpfi_complex.h", "ext/mpfi_matrix/mpfi/ruby_mpfi.h", "ext/mpfi_matrix/mpfi/ruby_mpfi_complex.h", "ext/mpfi_matrix/mpfi/ruby_mpfi_matrix.c", "ext/mpfi_matrix/mpfi/ruby_mpfi_matrix.h", "ext/mpfi_matrix/mpfi/ruby_mpfr.h", "ext/mpfi_matrix/mpfi/ruby_mpfr_matrix.h", "lib/mpfi/matrix.rb", "lib/mpfi/version.rb", "ruby-mpfi.gemspec", "script/console", "script/destroy", "script/generate", "spec/mpfi/generate_number_module.rb", "spec/mpfi/mpfi_alloc_spec.rb", "spec/mpfi/mpfi_diam_arithmetic_spec.rb", "spec/mpfi/mpfi_interval_arithmetic_spec.rb", "spec/mpfi/mpfi_interval_functions_spec.rb", "spec/mpfi/mpfi_math_functions_spec.rb", "spec/mpfi/mpfi_set_operation_spec.rb", "spec/mpfi/ruby-mpfi_spec.rb", "spec/mpfi/spec_helper.rb", "spec/mpfi_complex/spec_helper.rb", "spec/mpfi_matrix/generate_matrix_arguments.rb", "spec/mpfi_matrix/mpfi_matrix_alloc_spec.rb", "spec/mpfi_matrix/mpfi_matrix_arithmetic_spec.rb", "spec/mpfi_matrix/mpfi_matrix_interval_func_spec.rb", "spec/mpfi_matrix/mpfi_matrix_set_element_spec.rb", "spec/mpfi_matrix/mpfi_matrix_set_operation_spec.rb", "spec/mpfi_matrix/mpfi_matrix_string_spec.rb", "spec/mpfi_matrix/mpfi_matrix_subdivision_spec.rb", "spec/mpfi_matrix/mpfi_square_matrix_spec.rb", "spec/mpfi_matrix/mpfi_vector_spec.rb", "spec/mpfi_matrix/spec_helper.rb", "spec/spec.opts", "tasks/extconf.rake"]
+  s.homepage = %q{http://github.com/#{github_username}/#{project_name}}
+  s.post_install_message = %q{PostInstall.txt}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{ruby-mpfi}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{FIX (describe your package)}
+
+  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/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/ruby-mpfi.rb'}"
+puts "Loading ruby-mpfi gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/mpfi/generate_number_module.rb

@@ -0,0 +1,48 @@
+module GenerateNumber
+
+  def self.interval_float_arguments(number, max = 100)
+    ret = Array.new(number){ |j| self.float(2).sort }
+  end
+  
+  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/mpfi/mpfi_alloc_spec.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'spec'
+require 'mpfr'
+require 'mpfi'
+require "#{File.dirname(File.expand_path(__FILE__))}/generate_number_module.rb"
+
+describe MPFI, "when initializing MPFI instance" do
+  before(:all) do
+    @prec = 150
+    MPFR.set_default_prec(@prec)
+    @srcs = GenerateNumber.float(1000) + GenerateNumber.float(1000).map!{ |a| MPFR.new(a.to_s) }
+    @args = @srcs.map{ |a| MPFI.new(a) }
+  end
+
+  it "should include source number and has endpoints which is MPFR" do
+    @args.each_with_index do |a, i|
+      a.get_prec.should eql @prec
+      endpoints = a.endpoints
+      endpoints.each do |b|
+        b.should be_an_instance_of MPFR
+        b.get_prec.should eql @prec
+      end
+      endpoints[0].should <= @srcs[i]
+      endpoints[1].should >= @srcs[i]
+      a.include?(@srcs[i]).should be_true
+    end
+  end
+  
+end
+
+describe MPFI, "when initializing MPFI instance by method interval" do
+  before(:all) do
+    @prec = 130
+    MPFR.set_default_prec(@prec)
+    @srcs = GenerateNumber.interval_float_arguments(1000)
+    @srcs += GenerateNumber.interval_float_arguments(1000).map!{ |a| a.map!{ |b| MPFR.new(b.to_s) }}
+    @args = @srcs.map { |a| MPFI.interval(*a) }
+  end
+
+  it "should include source numbers and has endpoints which is MPFR" do
+    @args.each_with_index do |a, i|
+      a.get_prec.should eql @prec
+      endpoints = a.endpoints
+      endpoints.each do |b|
+        b.should be_an_instance_of MPFR
+        b.get_prec.should eql @prec
+      end
+      endpoints[0].should <= @srcs[i][0]
+      endpoints[1].should >= @srcs[i][1]
+      @srcs[i].each { |b| a.include?(b).should be_true }
+    end
+  end
+
+end
+

data/spec/mpfi/mpfi_diam_arithmetic_spec.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'spec'
+require 'mpfr'
+require 'mpfi'
+require "#{File.dirname(File.expand_path(__FILE__))}/generate_number_module.rb"
+
+describe MPFI, "when puting arithmetic operation" do
+  before(:all) do
+    MPFR.set_default_prec(150)
+    @args = GenerateNumber.float(5000).map{ |a| MPFI.new(a) }
+  end
+
+  it "should increase diameter" do
+    @args.each_index do |i|
+      if i > 0
+        diam_sum = @args[i-1].diam + @args[i].diam
+        add = @args[i-1] + @args[i]
+        sub = @args[i-1] - @args[i]
+        add.diam.should >= diam_sum
+        sub.diam.should >= diam_sum
+      end
+    end
+  end
+  
+end

data/spec/mpfi/mpfi_interval_arithmetic_spec.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'spec'
+require 'mpfr'
+require 'mpfi'
+require "#{File.dirname(File.expand_path(__FILE__))}/generate_number_module.rb"
+
+#
+# To test method +, -, / and *, we calculate these operator for MPFR and MPFI
+# and check whether resultant MPFI instance includes MPFR instance.
+# Then, this program make MPFI instance to use MPFI.new and MPFI.interval.
+#
+
+def check_arithmetic_op_include(arg1, arg2, &block)
+  mpfr_res = yield(MPFR.new(arg1), MPFR.new(arg2))
+  mpfi_res = yield(MPFI.new(arg1), MPFI.new(arg2))
+  mpfi_res.include?(mpfr_res)
+end
+
+def check_arithmetic_op_include2(arg1, arg2, error, &block)
+  ary = [MPFR.new(arg1), MPFR.new(arg2)]
+  mpfr_res = yield(ary[0], ary[1])
+  mpfi_res = yield(MPFI.interval(ary[0] - error, ary[0] + error),
+                   MPFI.interval(ary[1] - error, ary[1] + error))
+  mpfi_res.include?(mpfr_res)
+end
+
+describe MPFI, "when applying arithmetic operations" do
+  before(:all) do
+    MPFR.set_default_prec(100)
+    @args = GenerateNumber.float(5000)
+    @error = MPFR.new('1e-20')
+  end
+
+  it "should be include" do
+    @args.each_index do |i|
+      if i > 0
+        (check_arithmetic_op_include(@args[i-1], @args[i]) { |a, b| a + b }).should be_true
+        (check_arithmetic_op_include(@args[i-1], @args[i]) { |a, b| a - b }).should be_true
+        (check_arithmetic_op_include(@args[i-1], @args[i]) { |a, b| a * b }).should be_true
+        (check_arithmetic_op_include(@args[i-1], @args[i]) { |a, b| a / b }).should be_true
+
+        (check_arithmetic_op_include2(@args[i-1], @args[i], @error) { |a, b| a + b }).should be_true
+        (check_arithmetic_op_include2(@args[i-1], @args[i], @error) { |a, b| a - b }).should be_true
+        (check_arithmetic_op_include2(@args[i-1], @args[i], @error) { |a, b| a * b }).should be_true
+        (check_arithmetic_op_include2(@args[i-1], @args[i], @error) { |a, b| a / b }).should be_true
+      end
+    end
+  end
+  
+end
+
+# It is assumed that op is :add, :sub, :mul or :div.
+def arithmetic_op_with_mpfr(arg_r, arg_i, op, &block)
+  r = MPFR.new(arg_r)
+  i = MPFI.new(arg_i)
+  res = MPFI::Math.send(op, i, r)
+  res.should be_an_instance_of MPFI
+  res.left.should eql MPFR::Math.send(op, i.left, r, MPFR::RNDD)
+  res.right.should eql MPFR::Math.send(op, i.right, r, MPFR::RNDU)
+end
+
+describe MPFI, "when applying arithmetic operations with MPFR" do
+  before(:all) do
+    MPFR.set_default_prec(200)
+    @args = GenerateNumber.float(5000)
+  end
+
+  it "should be include" do
+    @args.each_index do |i|
+      if i > 0
+        arithmetic_op_with_mpfr(@args[i-1], @args[i], :add)
+        arithmetic_op_with_mpfr(@args[i-1], @args[i], :sub)
+        arithmetic_op_with_mpfr(@args[i-1], @args[i], :mul)
+        arithmetic_op_with_mpfr(@args[i-1], @args[i], :div)
+      end
+    end
+  end
+  
+end
+
+# op must be :add or :sub.
+def arithmetic_op_with_mpfr2(arg_r, arg_i, op, &block)
+  r = MPFR.new(arg_r)
+  i = MPFI.interval(*arg_i)
+  res = MPFI::Math.send(op, i, r)
+  res.should be_an_instance_of MPFI
+  res.left.should eql MPFR::Math.send(op, i.left, r, MPFR::RNDD)
+  res.right.should eql MPFR::Math.send(op, i.right, r, MPFR::RNDU)
+  res.diam_abs.should eql i.diam_abs
+end
+
+describe MPFI, "when applying addition or subtraction with MPFR" do
+  before(:all) do
+    MPFR.set_default_prec(200)
+    @args_r = GenerateNumber.float(5000)
+    @args_i = GenerateNumber.interval_float_arguments(5000)
+  end
+
+  it "should be include" do
+    @args_r.each_index do |i|
+      arithmetic_op_with_mpfr2(@args_r[i], @args_i[i], :add)
+      arithmetic_op_with_mpfr2(@args_r[i], @args_i[i], :sub)
+    end
+  end
+end

data/spec/mpfi/mpfi_interval_functions_spec.rb

@@ -0,0 +1,95 @@
+require 'rubygems'
+require 'spec'
+require 'mpfr'
+require 'mpfi'
+require "#{File.dirname(File.expand_path(__FILE__))}/generate_number_module.rb"
+
+#
+# The following is test for interval functions and endpoints. 
+#
+
+describe MPFI, "when executing interval functions" do
+  before(:all) do
+    MPFR.set_default_prec(140)
+    @args = GenerateNumber.float(1000).map{ |a| MPFI.new(a.to_s) }
+  end
+
+  it "should be equal the distance between endpoints" do
+    @args.each { |a| a.diam_abs.should >= (a.right - a.left) }
+  end
+
+  it "should be equal midpoint" do
+    @args.each { |a| a.mid.should == ((a.right + a.left) / 2) }
+  end
+
+  it "should include midpoint" do
+    @args.each { |a| a.mid_interval.include?(a.mid).should be_true }
+  end
+
+  it "should be include self.alea" do
+    @args.each { |a| a.include?(a.alea).should be_true }
+  end
+  
+end
+
+describe MPFI, "when getting endpoints of interval" do
+  before(:all) do
+    MPFR.set_default_prec(200)
+    @args = GenerateNumber.float(1000).map{ |a| MPFI.new(a.to_s) }
+  end
+
+  it "should include two endpoints" do
+    @args.each do |a|
+      a.include?(a.left).should be_true
+      a.include?(a.right).should be_true
+    end
+  end
+
+  it "should not strictly include interval which consists of one endpoint" do
+    @args.each do |a|
+      a.strictly_include?(MPFI.new(a.left)).should be_nil
+      a.strictly_include?(MPFI.new(a.right)).should be_nil
+    end
+  end
+  
+  it "should equal [left, right]." do
+    @args.each do |a|
+      epts = a.endpoints
+      a.left.should eql epts[0]
+      a.right.should eql epts[1]
+    end
+  end
+  
+end
+
+describe MPFI, "when dividing interval" do
+  before(:all) do
+    MPFR.set_default_prec(200)
+    @num = 5
+    @args = [MPFI.interval(2, 8), MPFI.interval('-1e-2', '8.2e-2'), MPFI.interval('-1e2', '-3.738e1')]
+    @error = MPFR.new('1e-20')
+  end
+
+  it "should split to some pieces" do
+    @args.each do |x|
+      res = x.subdivision(@num)
+      res.size.should eql @num
+      l = x.diam_abs / @num
+      res.each { |a| (a.diam_abs - l).abs.should <= @error }
+      (1...(@num - 1)).each { |i| res[i].left.should eql res[i-1].right }
+      res[0].left.should eql x.left
+      res[-1].right.should eql x.right
+    end
+  end
+
+  it "should return unchanged object" do
+    @args.each do |x|
+      res = x.subdivision(1)
+      res.size.should eql 1
+      l = x.diam_abs
+      res.each { |a| (a.diam_abs - l).abs.should <= @error }
+      res[0].should eql x
+    end
+  end
+end
+

data/spec/mpfi/mpfi_math_functions_spec.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'spec'
+require 'mpfr'
+require 'mpfi'
+require "#{File.dirname(File.expand_path(__FILE__))}/generate_number_module.rb"
+
+
+describe MPFI, "when calculating mathematical functions" do
+  it "should not raise error" do
+    MPFR.set_default_prec(256)
+    num = MPFI.new('4.2184930258398098')
+    p MPFI::Math.sqr(num)
+    p MPFI::Math.sqrt(num)
+  end
+end
+