ruby-mpfi 0.0.2

data/spec/mpfi/mpfi_set_operation_spec.rb

@@ -0,0 +1,102 @@
+require 'rubygems'
+require 'spec'
+require 'mpfr'
+require 'mpfi'
+require "#{File.dirname(File.expand_path(__FILE__))}/generate_number_module.rb"
+
+describe MPFI, "when checking inclusive relations" do
+  before(:all) do
+    @a = MPFI.interval(-2, 5)
+    @b = MPFI.interval(-3, 2)
+    @c = MPFI.interval(5, 8)
+    @d = MPFI.interval(7, 9)
+    @e = MPFI.interval(-2, 0)
+    @f = MPFI.interval(-1, 0)
+  end
+
+  it "should be some variations of return value for method include?." do
+    @a.include?(@b).should be_nil
+    @a.include?(@c).should be_nil
+    @a.include?(@d).should be_nil
+    @a.include?(@e).should be_true
+    @a.include?(@f).should be_true
+
+    @a.strictly_include?(@b).should be_nil
+    @a.strictly_include?(@c).should be_nil
+    @a.strictly_include?(@d).should be_nil
+    @a.strictly_include?(@e).should be_nil
+    @a.strictly_include?(@f).should be_true
+
+    @a.intersect(@b).should be_true
+    @a.intersect(@c).should be_true
+    @a.intersect(@d).should be_nil
+    @a.intersect(@e).should be_true
+    @a.intersect(@f).should be_true
+  end
+  
+end
+
+describe MPFI, "when making intersection of two intervals" do
+  before(:all) do
+    MPFR.set_default_prec(200)
+    src = [[2, 3], [4, 5], [-7, 0]]
+    tmp = GenerateNumber.float_arguments(2, 200).map { |a| a[0] < a[1] ? MPFI.interval(*a) : MPFI.interval(a[1], a[0])}
+    @base = [MPFI.interval(1, 3)] + tmp[0...20]
+    @intervals = src.map{ |a| MPFI.interval(*a) } + tmp[20..-1]
+  end
+
+  it "should return intersection intervals or nil" do
+    res = [0, 0]
+    @base.each do |a|
+      @intervals.each do |b|
+        intersect = a.intersect(b)
+        if a.left > b.right || a.right < b.left
+          intersect.should be_nil
+          a.intersect2(b).empty?.should be_true
+          res[1] += 1
+        else
+          intersect.should == MPFI.interval([a.left, b.left].max, [a.right, b.right].min)
+          intersect.should == a.intersect2(b)
+          a.include?(intersect).should be_true
+          b.include?(intersect).should be_true
+          res[0] += 1
+        end
+      end
+    end
+  end
+
+end
+
+describe MPFI, "when checking whether interval is bounded or not bounded" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @bounded = GenerateNumber.float_arguments(2, 200).map { |a| a[0] < a[1] ? MPFI.interval(*a) : MPFI.interval(a[1], a[0])}
+    @unbounded = [[MPFR.new(3), MPFR.pinf], [MPFR.minf, MPFR.new(-9)]].map { |a| MPFI.interval(*a)}
+  end
+
+  it "should be bounded" do
+    @bounded.each { |a| a.bounded?.should be_true }
+  end
+
+  it "should be unbounded" do
+    @unbounded.each { |a| a.bounded?.should be_nil }
+  end
+  
+end
+
+describe MPFI, "when making interval" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @sources = GenerateNumber.float_arguments(2, 100)
+  end
+
+  it "should not raise error" do
+    @sources.each do |a|
+      interval = nil
+      lambda { interval = (a[0] < a[1] ? MPFI.interval(a[0].to_s, a[1].to_s) : MPFI.interval(a[1].to_s, a[0].to_s)) }.should_not raise_error
+      interval.include?(MPFR.new(a[0].to_s)).should be_true
+      interval.include?(MPFR.new(a[1].to_s)).should be_true
+    end
+  end
+  
+end

data/spec/mpfi/ruby-mpfi_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "Place your specs here" do
+  
+  it "find this spec in spec directory" do
+    # violated "Be sure to write your specs"
+  end
+  
+end

data/spec/mpfi/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'mpfi'

data/spec/mpfi_complex/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'mpfi'

data/spec/mpfi_matrix/generate_matrix_arguments.rb

@@ -0,0 +1,65 @@
+module GenerateNumber
+
+  def self.float_matrix_interval_arguments(number, row, column, max = 100)
+    Array.new(number){ |j| Array.new(row){ |i| Array.new(column) { |k| GenerateNumber.float(2, max).sort } } }
+  end 
+  
+  def self.float_matrix_arguments(number, row, column, max = 100)
+    ret = []
+    (0...number).each do
+      ret << Array.new(row){ |j| Array.new(column){ |i| rand(max) - rand } }
+      for i in 0...(ret[-1].size)
+        ret[-1][i].map!{ |a| (rand > 0.5 ? -a : a) }
+      end
+    end
+    ret
+  end
+
+  def self.float_vector_arguments(number, size, max = 100)
+    ret = []
+    (0...number).each { ret << Array.new(size){ |i| rand(max) - rand } }
+    ret
+  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_matrix/mpfi_matrix_alloc_spec.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+#
+# 03/19/09 11:51:21
+# This spec test is almost same test as the one for mpfr/matrix.
+#
+
+describe "initialization of matrix" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @sizes = [[1, 2], [2, 3], [8, 5], [7, 3]]
+    @matrixes = @sizes.map{ |a| MPFI::Matrix.new(*a) }
+  end
+
+  it "should has size which equals size of array." do
+    @matrixes.each_with_index do |a, i|
+      a.size.should == (@sizes[i][0] * @sizes[i][1])
+    end
+  end
+
+  it "should has size of row which equals size of array." do
+    @matrixes.each_with_index do |a, i|
+      a.row_size.should == @sizes[i][0]
+    end
+  end
+
+  it "should has size of column which equals size of array." do
+    @matrixes.each_with_index do |a, i|
+      a.column_size.should == @sizes[i][1]
+    end
+  end
+
+  it "should have MPFI instances as elements." do
+    @matrixes.each do |m|
+      m.each { |a| a.should be_an_instance_of MPFI }
+    end
+  end
+  
+end
+
+describe "argument error raises for invalid initialization argument" do
+  before(:all) do
+    MPFR.set_default_prec(256)
+    @data = [[[1, 2, 3], [0, 0]],
+             [[MPFI.new(0)], [MPFI.new(1), 3]]]
+  end
+  
+  it "should make error for invalid array argument" do
+    @data.each do |ary|
+      lambda { MPFI::Matrix.new(ary) }.should raise_error ArgumentError
+    end
+  end
+end
+
+describe "when methods of matrix 'dup' and 'transpose' are executed" do
+  before(:all) do
+    MPFR.set_default_prec(256)
+    @data = [[[1, 2], [3, 3]],
+             [[-1, 0.8], ['1.2342', 99]],
+             [[36.237582938, 7122], ['-1e7', 8237]],
+             [[-2.2738, 8.23, 9.237482], [11, '8237.2374', '1239']],
+             [[MPFI.new('23'), MPFI.new('123.23')], [MPFI.new(-3.2378), MPFI.new('1.2837')]]]
+    @matrixes = @data.map{ |a| MPFI::Matrix.new(a) }
+  end
+
+  it "should have MPFI instances as elements." do
+    @matrixes.each do |m|
+      m.each { |a| a.should be_an_instance_of MPFI }
+    end
+  end
+  
+  it "should create matrix which has same values as original and different object id." do
+    @matrixes.each do |m|
+      new = m.dup
+      m.object_id.should_not eql new.object_id
+      (0...(m.row_size)).each do |i|
+        (0...(m.column_size)).each { |j| m[i, j].should eql new[i, j] }
+      end
+      m.should == new
+    end
+  end
+  
+  it "should has transposed values." do
+    @matrixes.each do |m|
+      id = m.object_id
+      old = m.dup
+      new = m.transpose
+      m.transpose!
+      m.should_not == old
+      m.should == new
+      m.object_id.should == id
+      m.object_id.should_not == new.object_id
+      m.column_size.should == old.row_size
+      m.row_size.should == old.column_size
+    end
+  end
+end
+
+describe "when methods of vector 'dup' and 'transpose' are executed" do
+  before(:all) do
+    MPFR.set_default_prec(768)
+    @data = [[1, 2, 3, 3],
+             [-1, 0.8, '1.2342', 99],
+             [36.237582938, 7122, '-1e7', 8237],
+             [-2.2738, 8.23, 9.237482, '8237.2374', '1239'],
+             [MPFI.new('23'), MPFI.new('123.23'), MPFI.new(-3.2378), MPFI.new('1.2837')]]
+    @column = @data.map{ |a| MPFI::ColumnVector.new(a) }
+    @row = @data.map{ |a| MPFI::RowVector.new(a) }
+  end
+
+  it "should create matrix which has same values as original and different object id." do
+    (@column + @row).each do |m|
+      new = m.dup
+      m.object_id.should_not == new.object_id
+      m.should == new
+    end
+  end
+
+  it "should change row vector to column vector and make the opposite changes" do
+    (@column + @row).each do |m|
+      id = m.object_id
+      old = m.dup
+      new = m.transpose
+      m.transpose!
+      m.should_not == old
+      m.should == new
+      m.object_id.should == id
+      m.object_id.should_not == new.object_id
+      m.column_size.should == old.row_size
+      m.row_size.should == old.column_size
+    end
+  end
+  
+end

data/spec/mpfi_matrix/mpfi_matrix_arithmetic_spec.rb

@@ -0,0 +1,156 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFI::Matrix, "when making matrix negative" do
+  before(:all) do
+    MPFR.set_default_prec(512)
+    @row = 8
+    @column = 3
+    @args = GenerateNumber.float_matrix_arguments(1000, @row, @column).map{ |a| MPFI::Matrix.new(a) }
+  end
+
+  it "should be negative" do
+    zero_matrix = MPFI::Matrix.new(@row, @column)
+    @args.each { |m| (zero_matrix - m).should == m.neg }
+  end
+  
+end
+
+describe MPFI::Matrix, "when arithmetic operator applies to 2x3 matrixies" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @row = 2
+    @column = 3
+    args = GenerateNumber.float_matrix_arguments(1000, @row, @column)
+    @args_i = args.map{ |a| MPFI::Matrix.new(a) }
+    @args_r = args.map{ |a| MPFR::Matrix.new(a) }
+  end
+
+  it "should be added" do
+    @args_i.each_index do |i|
+      if i > 0
+        res = @args_i[i-1] + @args_i[i]
+        (0...@row).each do |j|
+          (0...@column).each { |k| res[j, k].should eql(@args_i[i-1][j, k] + @args_i[i][j, k]) }
+        end
+        res.include?(@args_r[i-1] + @args_r[i]).should be_true
+      end
+    end
+  end
+
+  it "should be subtracted" do
+    @args_i.each_index do |i|
+      if i > 0
+        res = @args_i[i-1] - @args_i[i]
+        (0...@row).each do |j|
+          (0...@column).each { |k| res[j, k].should eql(@args_i[i-1][j, k] - @args_i[i][j, k]) }
+        end
+        res.include?(@args_r[i-1] - @args_r[i]).should be_true
+      end
+    end
+  end
+
+  it "should be multiplied" do
+    @args_i.each_index do |i|
+      if i > 0
+        trans = @args_i[i].transpose
+        res = @args_i[i-1] * trans
+        (0...@row).each do |j|
+          (0...@row).each do |k|
+            res2 = MPFI.new(0)
+            (0...@column).each { |l| res2 += @args_i[i-1][j, l] * trans[l, k] }
+            res[j, k].should eql res2
+          end
+        end
+        res.include?(@args_r[i-1] * @args_r[i].transpose).should be_true
+        
+        trans = @args_i[i-1].transpose
+        res = trans * @args_i[i]
+        (0...@column).each do |j|
+          (0...@column).each do |k|
+            res2 = MPFI.new(0)
+            (0...@row).each { |l| res2 += trans[j, l] * @args_i[i][l, k] }
+            res[j, k].should eql res2
+          end
+        end
+        res.include?(@args_r[i-1].transpose * @args_r[i]).should be_true
+      end
+    end
+  end
+
+  it "should be multyplied by scalar" do
+    @args_i.each do |a|
+      scalar = MPFI.new(GenerateNumber.float(1)[0])
+      res = a.mul_scalar(scalar)
+      (0...@row).each do |j|
+        (0...@column).each { |k| res[j, k].should eql a[j, k] * scalar }
+      end
+    end
+  end
+  
+  it "should be divided by scalar" do
+    @args_i.each do |a|
+      scalar = MPFI.new(GenerateNumber.float(1)[0])
+      res = a.div_scalar(scalar)
+      (0...@row).each do |j|
+        (0...@column).each { |k| res[j, k].should eql a[j, k] / scalar }
+      end
+    end
+  end
+  
+end
+
+describe MPFI::Matrix, "when arithmetic operator applies to 2x3 MPFR::Matrix" do
+  before(:all) do
+    MPFR.set_default_prec(175)
+    @row = 2
+    @column = 3
+    @args = GenerateNumber.float_matrix_arguments(1000, @row, @column)
+  end
+
+  it "should be added" do
+    @args.each_index do |i|
+      if i > 0
+        rmat = MPFR::Matrix.new(@args[i-1])
+        imat = MPFI::Matrix.new(@args[i])
+        res = imat.add(rmat)
+        res.should be_an_instance_of MPFI::Matrix
+        (0...@row).each do |j|
+          (0...@column).each { |k| (imat[j, k] + rmat[j, k]).should eql res[j, k] }
+        end
+      end
+    end
+  end
+
+  it "should be subtracted" do
+    @args.each_index do |i|
+      if i > 0
+        rmat = MPFR::Matrix.new(@args[i-1])
+        imat = MPFI::Matrix.new(@args[i])
+        res = imat.sub(rmat)
+        res.should be_an_instance_of MPFI::Matrix
+        (0...@row).each do |j|
+          (0...@column).each { |k| (imat[j, k] - rmat[j, k]).should eql res[j, k] }
+        end
+      end
+    end
+  end
+
+  it "should be multiplied" do
+    @args.each_index do |i|
+      if i > 0
+        rmat = MPFR::Matrix.new(@args[i-1]).transpose
+        imat = MPFI::Matrix.new(@args[i])
+        res = imat.mul(rmat)
+
+        (0...@row).each do |j|
+          (0...@row).each do |k|
+            res2 = MPFI.new(0)
+            (0...@column).each { |l| res2 += (imat[j, l] * rmat[l, k]) }
+            res[j, k].should eql res2
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/mpfi_matrix/mpfi_matrix_interval_func_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFI::Matrix, "when making mid_interval" do
+  before(:all) do
+    MPFR.set_default_prec(512)
+    @row = 4
+    @column = 1
+    @args = GenerateNumber.float_vector_arguments(1000, @row, @column).map{ |a| MPFI::ColumnVector.new(a) }
+  end
+
+  it "should have mid_interval including midpoint" do
+    @args.each do |a|
+      mid_int = a.mid_interval
+      a.include?(mid_int).should be_true
+      mid_int.include?(a.mid).should be_true
+    end
+  end
+
+  it "should have midpoint of two points." do
+    @args.each_with_index do |a, ind|
+      m = a.midpoint(@args[ind-1])
+      m2 = (a + @args[ind-1]).div_scalar(MPFI.new(2))
+      (0...@row).each do |i|
+        m[i].should == m2[i]
+      end
+      m.include?(a.mid.midpoint(@args[ind-1].mid)).should be_true
+    end
+  end
+end
+

data/spec/mpfi_matrix/mpfi_matrix_set_element_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFI::Matrix, "when setting number to particular element" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @row = 4
+    @column = 7
+    @matrix = MPFI::Matrix.new(@row, @column)
+    @source = GenerateNumber.float_matrix_arguments(1, @row, @column)[0]
+  end
+
+  it "should have elements which equals to source number." do
+    (0...(@matrix.row_size)).each do |i|
+      (0...(@matrix.column_size)).each do |j|
+        fr = MPFI.new(@source[i][j].to_s)
+        @matrix.set_element(i, j, fr)
+        @matrix[i, j].should eql fr
+      end
+    end
+  end
+
+end
+
+describe MPFI::Matrix, "when calculating row and column" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @row = 6
+    @column = 4
+    @sources = GenerateNumber.float_matrix_arguments(100, @row, @column)
+    @matrixies = @sources.map { |a| MPFI::Matrix.new(a) }
+  end
+
+  it "should have row vector." do
+    @matrixies.each do |m|
+      (0...(m.column_size)).each do |i|
+        col = m.column(i)
+        (0...(m.row_size)).each do |j|
+          col[j].should eql m[j, i]
+        end
+      end
+    end
+  end
+
+  it "should have column vector." do
+    @matrixies.each do |m|
+      (0...(m.row_size)).each do |i|
+        row = m.row(i)
+        (0...(m.column_size)).each do |j|
+          row[j].should eql m[i, j]
+        end
+      end
+    end
+  end
+  
+end

data/spec/mpfi_matrix/mpfi_matrix_set_operation_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFI::Matrix, "when an interval includes other" do
+  before(:all) do
+    MPFR.set_default_prec(100)
+    @row = 3
+    @column = 2
+    tmp = GenerateNumber.float_matrix_interval_arguments(100, @row, @column).map{ |a| MPFI::Matrix.interval(a) }
+    @args1 = tmp[0...50]
+    @args2 = tmp[50..-1]
+  end
+
+  
+end
+
+describe MPFI::Matrix, "when a box intersects other" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @row = 3
+    @column = 2
+    tmp = GenerateNumber.float_matrix_interval_arguments(100, @row, @column).map{ |a| MPFI::Matrix.interval(a) }
+    @args1 = tmp[0...50]
+    @args2 = tmp[50..-1]
+  end
+
+  it "should return box or nil" do
+    total = [0,0]
+    @args1.each do |a1|
+      @args2.each do |a2|
+        res = a1.intersect(a2)
+        tmp = []
+        (0...(a1.size)).each { |k| tmp << a1.at(k).intersect(a2.at(k)) }
+        if tmp.any?{ |b| NilClass === b }
+          res.should be_nil
+          total[1] += 1
+        else
+          (0...(res.size)).each { |k| res.at(k).should == tmp[k] }
+          a1.include?(res).should be_true
+          a2.include?(res).should be_true
+          total[0] += 1
+        end
+      end
+    end
+  end
+end
+
+describe MPFI::Matrix, "when checking whether matrix is bounded or not bounded" do
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @row = 2
+    @column = 3
+    @bounded = GenerateNumber.float_matrix_interval_arguments(100, @row, @column).map{ |a| MPFI::Matrix.interval(a) }
+    @unbounded = GenerateNumber.float_matrix_interval_arguments(100, @row, @column).map do |a|
+      if rand > 0.5
+        a[rand(@row)][rand(@column)][0] = MPFR.minf
+      else
+        a[rand(@row)][rand(@column)][1] = MPFR.pinf
+      end
+      MPFI::Matrix.interval(a)
+    end
+  end
+
+  it "should be bounded" do
+    @bounded.each { |a| a.bounded?.should be_true }
+  end
+
+  it "should be unbounded" do
+    @unbounded.each { |a| a.bounded?.should be_nil }
+  end
+  
+end

data/spec/mpfi_matrix/mpfi_matrix_string_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "when MPFI instance is converted to string by some methods." do
+  
+  before(:all) do
+    MPFR.set_default_prec(128)
+    @row = 2
+    @column = 3
+    @matrixes = ((0..100).map { |i| MPFI::Matrix.new(GenerateNumber.float_arguments(@column, @row)) })
+  end
+
+  it "should return array having strings." do
+    @matrixes.each do |m|
+      m.str_ary_for_inspect.each_with_index do |s, i|
+        s.should eql "#{m[i % @row, i / @row].left.to_strf('%.Re')} #{m[i % @row, i / @row].right.to_strf('%.Re')}"
+      end
+    end
+  end
+
+  it "should return inspect string." do
+    @matrixes.each do |m|
+      ins = m.inspect
+      ins.should match(/#{Regexp.escape(sprintf("%x", m.object_id))}/)
+      m.each do |a|
+        str = "#{a.left.to_strf('%.Re')} #{a.right.to_strf('%.Re')}"
+        ins.should match(/#{Regexp.escape(str)}/)
+      end
+    end
+  end
+  
+end
+

data/spec/mpfi_matrix/mpfi_matrix_subdivision_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe MPFI::Matrix, "when subdividing interval" do
+  before(:all) do
+    @size = MPFR.new('1')
+    @arg = MPFI::ColumnVector.new([MPFI.interval(-1.8, -1.729), MPFI.interval('-1e-2', '8.2e-2'), MPFI.interval('1.82', '2.27')])
+  end
+  
+  it "should return unchanged object" do
+    res = @arg.subdivision_by_size(@size)
+    res.size.should eql 1
+    res.each { |a| a.max_diam_abs.should <= @size }
+  end
+end