rubysl-matrix 1.0.0

data/spec/divide_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require 'matrix'
+
+describe "Matrix#/" do
+  before :each do
+    @a = Matrix[ [1, 2], [3, 4] ]
+    @b = Matrix[ [4, 5], [6, 7] ]
+    @c = Matrix[ [1.2, 2.4], [3.6, 4.8] ]
+  end
+
+  ruby_bug "?", "1.8.7" do
+    it "returns the result of dividing self by another Matrix" do
+      (@a / @b).should be_close_to_matrix([[2.5, -1.5], [1.5, -0.5]])
+    end
+  end
+
+  conflicts_with :Prime do
+    it "returns the result of dividing self by a Fixnum" do
+      (@a / 2).should == Matrix[ [0, 1], [1, 2] ]
+    end
+  end
+
+  conflicts_with :Prime do
+    it "returns the result of dividing self by a Bignum" do
+      (@a / bignum_value).should == Matrix[ [0, 0], [0, 0] ]
+    end
+  end
+
+  it "returns the result of dividing self by a Float" do
+    (@c / 1.2).should == Matrix[ [1, 2], [3, 4] ]
+  end
+
+  it "raises a Matrix::ErrDimensionMismatch if the matrices are different sizes" do
+    lambda { @a / Matrix[ [1] ] }.should raise_error(Matrix::ErrDimensionMismatch)
+  end
+
+  it "returns an instance of Matrix" do
+    (@a /@b).should be_kind_of(Matrix)
+  end
+
+  ruby_bug "redmine #5307", "1.9.3" do
+    describe "for a subclass of Matrix" do
+      it "returns an instance of that subclass" do
+        m = MatrixSub.ins
+        (m/m).should be_an_instance_of(MatrixSub)
+        (m/1).should be_an_instance_of(MatrixSub)
+      end
+    end
+  end
+
+  ruby_bug "redmine:2365", "1.8.7" do
+    it "raises a TypeError if other is of wrong type" do
+      lambda { @a / nil        }.should raise_error(TypeError)
+      lambda { @a / "a"        }.should raise_error(TypeError)
+      lambda { @a / [ [1, 2] ] }.should raise_error(TypeError)
+      lambda { @a / Object.new }.should raise_error(TypeError)
+    end
+  end
+end

data/spec/each_spec.rb

@@ -0,0 +1,77 @@
+require 'matrix'
+
+ruby_version_is "1.9.1" do
+  describe "Matrix#each" do
+    before :all do
+      @m = Matrix[ [1, 2, 3], [4, 5, 6] ]
+      @result = (1..6).to_a
+    end
+
+    it "returns an Enumerator when called without a block" do
+      enum = @m.each
+      enum.should be_an_instance_of(enumerator_class)
+      enum.to_a.should == @result
+    end
+
+    it "returns self" do
+      @m.each{}.should equal(@m)
+    end
+
+    it "yields the elements starting with the those of the first row" do
+      a = []
+      @m.each {|x| a << x}
+      a.should ==  @result
+    end
+  end
+end
+
+ruby_version_is "1.9.3" do
+  describe "Matrix#each with an argument" do
+    before :all do
+      @m = Matrix[ [1, 2, 3, 4], [5, 6, 7, 8] ]
+      @t = Matrix[ [1, 2], [3, 4], [5, 6], [7, 8] ]
+    end
+
+    it "raises an ArgumentError for unrecognized argument" do
+      lambda {
+        @m.each("all"){}
+      }.should raise_error(ArgumentError)
+      lambda {
+        @m.each(nil){}
+      }.should raise_error(ArgumentError)
+      lambda {
+        @m.each(:left){}
+      }.should raise_error(ArgumentError)
+    end
+
+    it "yields the rights elements when passed :diagonal" do
+      @m.each(:diagonal).to_a.should == [1, 6]
+      @t.each(:diagonal).to_a.should == [1, 4]
+    end
+
+    it "yields the rights elements when passed :off_diagonal" do
+      @m.each(:off_diagonal).to_a.should == [2, 3, 4, 5, 7, 8]
+      @t.each(:off_diagonal).to_a.should == [2, 3, 5, 6, 7, 8]
+    end
+
+    it "yields the rights elements when passed :lower" do
+      @m.each(:lower).to_a.should == [1, 5, 6]
+      @t.each(:lower).to_a.should == [1, 3, 4, 5, 6, 7, 8]
+    end
+
+    it "yields the rights elements when passed :strict_lower" do
+      @m.each(:strict_lower).to_a.should == [5]
+      @t.each(:strict_lower).to_a.should == [3, 5, 6, 7, 8]
+    end
+
+    it "yields the rights elements when passed :strict_upper" do
+      @m.each(:strict_upper).to_a.should == [2, 3, 4, 7, 8]
+      @t.each(:strict_upper).to_a.should == [2]
+    end
+
+    it "yields the rights elements when passed :upper" do
+      @m.each(:upper).to_a.should == [1, 2, 3, 4, 6, 7, 8]
+      @t.each(:upper).to_a.should == [1, 2, 4]
+    end
+  end
+end

data/spec/each_with_index_spec.rb

@@ -0,0 +1,84 @@
+require 'matrix'
+
+ruby_version_is "1.9.1" do
+  describe "Matrix#each_with_index" do
+    before :all do
+      @m = Matrix[ [1, 2, 3], [4, 5, 6] ]
+      @result = [
+        [1, 0, 0],
+        [2, 0, 1],
+        [3, 0, 2],
+        [4, 1, 0],
+        [5, 1, 1],
+        [6, 1, 2]
+      ]
+    end
+
+    it "returns an Enumerator when called without a block" do
+      enum = @m.each_with_index
+      enum.should be_an_instance_of(enumerator_class)
+      enum.to_a.should == @result
+    end
+
+    it "returns self" do
+      @m.each_with_index{}.should equal(@m)
+    end
+
+    it "yields the elements starting with the those of the first row" do
+      a = []
+      @m.each_with_index {|x, r, c| a << [x, r, c]}
+      a.should == @result
+    end
+  end
+end
+
+ruby_version_is "1.9.3" do
+  describe "Matrix#each_with_index with an argument" do
+    before :all do
+      @m = Matrix[ [1, 2, 3, 4], [5, 6, 7, 8] ]
+      @t = Matrix[ [1, 2], [3, 4], [5, 6], [7, 8] ]
+    end
+
+    it "raises an ArgumentError for unrecognized argument" do
+      lambda {
+        @m.each_with_index("all"){}
+      }.should raise_error(ArgumentError)
+      lambda {
+        @m.each_with_index(nil){}
+      }.should raise_error(ArgumentError)
+      lambda {
+        @m.each_with_index(:left){}
+      }.should raise_error(ArgumentError)
+    end
+
+    it "yields the rights elements when passed :diagonal" do
+      @m.each_with_index(:diagonal).to_a.should == [[1, 0, 0], [6, 1, 1]]
+      @t.each_with_index(:diagonal).to_a.should == [[1, 0, 0], [4, 1, 1]]
+    end
+
+    it "yields the rights elements when passed :off_diagonal" do
+      @m.each_with_index(:off_diagonal).to_a.should == [[2, 0, 1], [3, 0, 2], [4, 0, 3], [5, 1, 0], [7, 1, 2], [8, 1, 3]]
+      @t.each_with_index(:off_diagonal).to_a.should == [[2, 0, 1], [3, 1, 0], [5, 2, 0], [6, 2, 1], [7, 3, 0], [8, 3, 1]]
+    end
+
+    it "yields the rights elements when passed :lower" do
+      @m.each_with_index(:lower).to_a.should == [[1, 0, 0], [5, 1, 0], [6, 1, 1]]
+      @t.each_with_index(:lower).to_a.should == [[1, 0, 0], [3, 1, 0], [4, 1, 1], [5, 2, 0], [6, 2, 1], [7, 3, 0], [8, 3, 1]]
+    end
+
+    it "yields the rights elements when passed :strict_lower" do
+      @m.each_with_index(:strict_lower).to_a.should == [[5, 1, 0]]
+      @t.each_with_index(:strict_lower).to_a.should == [[3, 1, 0], [5, 2, 0], [6, 2, 1], [7, 3, 0], [8, 3, 1]]
+    end
+
+    it "yields the rights elements when passed :strict_upper" do
+      @m.each_with_index(:strict_upper).to_a.should == [[2, 0, 1], [3, 0, 2], [4, 0, 3], [7, 1, 2], [8, 1, 3]]
+      @t.each_with_index(:strict_upper).to_a.should == [[2, 0, 1]]
+    end
+
+    it "yields the rights elements when passed :upper" do
+      @m.each_with_index(:upper).to_a.should == [[1, 0, 0], [2, 0, 1], [3, 0, 2], [4, 0, 3], [6, 1, 1], [7, 1, 2], [8, 1, 3]]
+      @t.each_with_index(:upper).to_a.should == [[1, 0, 0], [2, 0, 1], [4, 1, 1]]
+    end
+  end
+end

data/spec/eigenvalue_decomposition/eigenvalue_matrix_spec.rb

@@ -0,0 +1,10 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::EigenvalueDecomposition#eigenvalue_matrix" do
+    it "returns a diagonal matrix with the eigenvalues on the diagonal" do
+      Matrix[[14, 16], [-6, -6]].eigensystem.eigenvalue_matrix.should == Matrix[[6, 0],[0, 2]]
+      Matrix[[1, 1], [-1, 1]].eigensystem.eigenvalue_matrix.should == Matrix[[Complex(1,1), 0],[0, Complex(1,-1)]]
+    end
+  end
+end

data/spec/eigenvalue_decomposition/eigenvalues_spec.rb

@@ -0,0 +1,23 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::EigenvalueDecomposition#eigenvalues" do
+    it "returns an array of complex eigenvalues for a rotation matrix" do
+      Matrix[[ 1, 1],
+             [-1, 1]].eigensystem.eigenvalues.sort_by{|v| v.imag}.should ==
+      [ Complex(1, -1), Complex(1, 1)]
+    end
+
+    it "returns an array of real eigenvalues for a symetric matrix" do
+      Matrix[[1, 2],
+             [2, 1]].eigensystem.eigenvalues.sort.map!{|x| x.round(10)}.should ==
+      [ -1, 3 ]
+    end
+
+    it "returns an array of real eigenvalues for a matrix" do
+      Matrix[[14, 16],
+             [-6, -6]].eigensystem.eigenvalues.sort.map!{|x| x.round(10)}.should ==
+      [ 2, 6 ]
+    end
+  end
+end

data/spec/eigenvalue_decomposition/eigenvector_matrix_spec.rb

@@ -0,0 +1,23 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::EigenvalueDecomposition#eigenvector_matrix" do
+    ruby_bug '#7208', '1.9.3' do
+      it "returns a complex eigenvector matrix given a rotation matrix" do
+        # Fix me: should test for linearity, not for equality
+        Matrix[[ 1, 1],
+               [-1, 1]].eigensystem.eigenvector_matrix.should ==
+        Matrix[[1, 1],
+               [Complex(0, 1), Complex(0, -1)]]
+      end
+    end
+
+    it "returns an real eigenvector matrix for a symetric matrix" do
+      # Fix me: should test for linearity, not for equality
+      Matrix[[1, 2],
+             [2, 1]].eigensystem.eigenvector_matrix.should ==
+      Matrix[[0.7071067811865475, 0.7071067811865475],
+             [-0.7071067811865475, 0.7071067811865475]]
+    end
+  end
+end

data/spec/eigenvalue_decomposition/eigenvectors_spec.rb

@@ -0,0 +1,25 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::EigenvalueDecomposition#eigenvectors" do
+    ruby_bug '#7208', '1.9.3' do
+      it "returns an array of complex eigenvectors for a rotation matrix" do
+        # Fix me: should test for linearity, not for equality
+        Matrix[[ 1, 1],
+               [-1, 1]].eigensystem.eigenvectors.should ==
+        [ Vector[1, Complex(0, 1)],
+          Vector[1, Complex(0, -1)]
+        ]
+      end
+    end
+
+    it "returns an array of real eigenvectors for a symetric matrix" do
+      # Fix me: should test for linearity, not for equality
+      Matrix[[1, 2],
+             [2, 1]].eigensystem.eigenvectors.should ==
+      [ Vector[0.7071067811865475, -0.7071067811865475],
+        Vector[0.7071067811865475, 0.7071067811865475]
+      ]
+    end
+  end
+end

data/spec/eigenvalue_decomposition/initialize_spec.rb

@@ -0,0 +1,27 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::EigenvalueDecomposition#initialize" do
+    it "raises an error if argument is not a matrix" do
+      lambda {
+        Matrix::EigenvalueDecomposition.new([[]])
+      }.should raise_error(TypeError)
+      lambda {
+        Matrix::EigenvalueDecomposition.new(42)
+      }.should raise_error(TypeError)
+    end
+
+    it "raises an error if matrix is not square" do
+      lambda {
+        Matrix::EigenvalueDecomposition.new(Matrix[[1, 2]])
+      }.should raise_error(Matrix::ErrDimensionMismatch)
+    end
+
+    ruby_bug "Fixed in Jama 1.0.3", "1.9.3" do
+      it "never hangs" do
+        m = Matrix[ [0,0,0,0,0], [0,0,0,0,1], [0,0,0,1,0], [1,1,0,0,1], [1,0,1,0,1] ]
+        Matrix::EigenvalueDecomposition.new(m).should_not == "infinite loop"
+      end
+    end
+  end
+end

data/spec/eigenvalue_decomposition/to_a_spec.rb

@@ -0,0 +1,19 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::EigenvalueDecomposition#to_a" do
+    before :each do
+      @a = Matrix[[14, 16], [-6, -6]]
+      @e = Matrix::EigenvalueDecomposition.new(@a)
+    end
+
+    it "returns an array of with [V, D, V.inv]" do
+      @e.to_a.should == [@e.v, @e.d, @e.v_inv]
+    end
+
+    it "returns a factorization" do
+      v, d, v_inv = @e.to_a
+      (v * d * v_inv).map{|e| e.round(10)}.should == @a
+    end
+  end
+end

data/spec/element_reference_spec.rb

@@ -0,0 +1,24 @@
+require 'matrix'
+
+describe "Matrix#[]" do
+
+  before(:all) do
+    @m = Matrix[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+  end
+
+  it "returns element at (i, j)" do
+    (0..3).each do |i|
+      (0..2).each do |j|
+        @m[i, j].should == (i * 3) + j
+      end
+    end
+  end
+
+  ruby_bug "#1518", "1.8.7" do
+    it "returns nil for an invalid index pair" do
+      @m[8,1].should be_nil
+      @m[1,8].should be_nil
+    end
+  end
+
+end

data/spec/empty_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../fixtures/classes', __FILE__)
+require 'matrix'
+
+ruby_version_is "1.8.8" do
+  describe "Matrix#empty?" do
+    it "returns true when the Matrix is empty" do
+      Matrix[ ].empty?.should be_true
+      Matrix[ [], [], [] ].empty?.should be_true
+      Matrix[ [], [], [] ].transpose.empty?.should be_true
+    end
+
+    it "returns false when the Matrix has elements" do
+      Matrix[ [1, 2] ].empty?.should be_false
+      Matrix[ [1], [2] ].empty?.should be_false
+    end
+
+    it "doesn't accept any parameter" do
+      lambda{
+        Matrix[ [1, 2] ].empty?(42)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "Matrix.empty" do
+    it "returns an empty matrix of the requested size" do
+      m = Matrix.empty(3, 0)
+      m.row_size.should == 3
+      m.column_size.should == 0
+
+      m = Matrix.empty(0, 3)
+      m.row_size.should == 0
+      m.column_size.should == 3
+    end
+
+    it "has arguments defaulting to 0" do
+      Matrix.empty.should == Matrix.empty(0, 0)
+      Matrix.empty(42).should == Matrix.empty(42, 0)
+    end
+
+    it "does not accept more than two parameters" do
+      lambda{
+        Matrix.empty(1, 2, 3)
+      }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error if both dimensions are > 0" do
+      lambda{
+        Matrix.empty(1, 2)
+      }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error if any dimension is < 0" do
+      lambda{
+        Matrix.empty(-2, 0)
+      }.should raise_error(ArgumentError)
+
+      lambda{
+        Matrix.empty(0, -2)
+      }.should raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "for a subclass of Matrix" do
+    it "returns an instance of that subclass" do
+      MatrixSub.empty(0, 1).should be_an_instance_of(MatrixSub)
+    end
+  end
+end