rubysl-matrix 1.0.0

data/spec/lup_decomposition/l_spec.rb

@@ -0,0 +1,19 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::LUPDecomposition#l" do
+    before :each do
+      @a = Matrix[[7, 8, 9], [14, 46, 51], [28, 82, 163]]
+      @lu = Matrix::LUPDecomposition.new(@a)
+      @l = @lu.l
+    end
+
+    it "returns the first element of to_a" do
+      @l.should == @lu.to_a[0]
+    end
+
+    it "returns a lower triangular matrix" do
+      @l.lower_triangular?.should be_true
+    end
+  end
+end

data/spec/lup_decomposition/p_spec.rb

@@ -0,0 +1,19 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::LUPDecomposition#p" do
+    before :each do
+      @a = Matrix[[7, 8, 9], [14, 46, 51], [28, 82, 163]]
+      @lu = Matrix::LUPDecomposition.new(@a)
+      @p = @lu.p
+    end
+
+    it "returns the third element of to_a" do
+      @p.should == @lu.to_a[2]
+    end
+
+    it "returns a permutation matrix" do
+      @p.permutation?.should be_true
+    end
+  end
+end

data/spec/lup_decomposition/solve_spec.rb

@@ -0,0 +1,54 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::LUPDecomposition#solve" do
+    describe "for rectangular matrices" do
+      it "raises an error for singular matrices" do
+        a = Matrix[[1, 2, 3], [1, 3, 5], [2, 5, 8]]
+        lu = Matrix::LUPDecomposition.new(a)
+        lambda {
+          lu.solve(a)
+        }.should raise_error(Matrix::ErrNotRegular)
+      end
+
+      describe "for non singular matrices" do
+        before :each do
+          @a = Matrix[[7, 8, 9], [14, 46, 51], [28, 82, 163]]
+          @lu = Matrix::LUPDecomposition.new(@a)
+        end
+
+        it "returns the appropriate empty matrix when given an empty matrix" do
+          @lu.solve(Matrix.empty(3,0)).should == Matrix.empty(3,0)
+          empty = Matrix::LUPDecomposition.new(Matrix.empty(0, 0))
+          empty.solve(Matrix.empty(0,3)).should == Matrix.empty(0,3)
+        end
+
+        it "returns the right matrix when given a matrix of the appropriate size" do
+          solution = Matrix[[1, 2, 3, 4], [0, 1, 2, 3], [-1, -2, -3, -4]]
+          values = Matrix[[-2, 4, 10, 16], [-37, -28, -19, -10], [-135, -188, -241, -294]] # == @a * solution
+          @lu.solve(values).should == solution
+        end
+
+        it "raises an error when given a matrix of the wrong size" do
+          values = Matrix[[1, 2, 3, 4], [0, 1, 2, 3]]
+          lambda {
+            @lu.solve(values)
+          }.should raise_error(Matrix::ErrDimensionMismatch)
+        end
+
+        it "returns the right vector when given a vector of the appropriate size" do
+          solution = Vector[1, 2, -1]
+          values = Vector[14, 55, 29] # == @a * solution
+          @lu.solve(values).should == solution
+        end
+
+        it "raises an error when given a vector of the wrong size" do
+          values = Vector[14, 55]
+          lambda {
+            @lu.solve(values)
+          }.should raise_error(Matrix::ErrDimensionMismatch)
+        end
+      end
+    end
+  end
+end

data/spec/lup_decomposition/to_a_spec.rb

@@ -0,0 +1,36 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::LUPDecomposition#to_a" do
+    before :each do
+      @a = Matrix[[7, 8, 9], [14, 46, 51], [28, 82, 163]]
+      @lu = Matrix::LUPDecomposition.new(@a)
+      @to_a = @lu.to_a
+      @l, @u, @p = @to_a
+    end
+
+    it "returns an array of three matrices" do
+      @to_a.should be_kind_of(Array)
+      @to_a.length.should == 3
+      @to_a.each{|m| m.should be_kind_of(Matrix)}
+    end
+
+    it "returns [l, u, p] such that l*u == a*p" do
+      (@l * @u).should == (@p * @a)
+    end
+
+    ruby_bug "#", "1.9.3" do
+      it "returns the right values for rectangular matrices" do
+        [
+          Matrix[[7, 8, 9], [14, 46, 51]],
+          Matrix[[4, 11], [5, 8], [3, 4]],
+        ].each do |a|
+          l, u, p = Matrix::LUPDecomposition.new(a).to_a
+          (l * u).should == (p * a)
+        end
+      end
+    end
+
+    it "has other properties implied by the specs of #l, #u and #p"
+  end
+end

data/spec/lup_decomposition/u_spec.rb

@@ -0,0 +1,19 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix::LUPDecomposition#u" do
+    before :each do
+      @a = Matrix[[7, 8, 9], [14, 46, 51], [28, 82, 163]]
+      @lu = Matrix::LUPDecomposition.new(@a)
+      @u = @lu.u
+    end
+
+    it "returns the second element of to_a" do
+      @u.should == @lu.to_a[1]
+    end
+
+    it "returns an upper triangular matrix" do
+      @u.upper_triangular?.should be_true
+    end
+  end
+end

data/spec/map_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../shared/collect', __FILE__)
+
+describe "Matrix#map" do
+  it_behaves_like(:collect, :map)
+end

data/spec/minor_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../fixtures/classes', __FILE__)
+require 'matrix'
+
+describe "Matrix#minor" do
+  before(:each) do
+    @matrix = Matrix[ [1,2], [3,4], [5,6] ]
+  end
+
+  describe "with start_row, nrows, start_col, ncols" do
+    it "returns the given portion of the Matrix" do
+      @matrix.minor(0,1,0,2).should == Matrix[ [1, 2] ]
+      @matrix.minor(1,2,1,1).should == Matrix[ [4], [6] ]
+    end
+
+    ruby_bug "redmine:1532", "1.8.7" do
+      it "returns an empty Matrix if nrows or ncols is 0" do
+        @matrix.minor(0,0,0,0).should == Matrix[]
+        @matrix.minor(1,0,1,0).should == Matrix[]
+        @matrix.minor(1,0,1,1).should == Matrix.columns([[]])
+        @matrix.minor(1,1,1,0).should == Matrix[[]]
+      end
+
+      it "returns nil for out-of-bounds start_row/col" do
+        r = @matrix.row_size + 1
+        c = @matrix.column_size + 1
+        @matrix.minor(r,0,0,10).should == nil
+        @matrix.minor(0,10,c,9).should == nil
+        @matrix.minor(-r,0,0,10).should == nil
+        @matrix.minor(0,10,-c,9).should == nil
+      end
+
+      it "returns nil for negative nrows or ncols" do
+        @matrix.minor(0,1,0,-1).should == nil
+        @matrix.minor(0,-1,0,1).should == nil
+      end
+
+      it "start counting backwards for start_row or start_col below zero" do
+        @matrix.minor(0, 1, -1, 1).should == @matrix.minor(0, 1, 1, 1)
+        @matrix.minor(-1, 1, 0, 1).should == @matrix.minor(2, 1, 0, 1)
+      end
+    end
+
+    it "returns empty matrices for extreme start_row/col" do
+      @matrix.minor(3,10,1,10).should == Matrix.columns([[]])
+      @matrix.minor(1,10,2,10).should == Matrix[[], []]
+      @matrix.minor(3,0,0,10).should == Matrix.columns([[], []])
+    end
+
+    it "ignores big nrows or ncols" do
+      @matrix.minor(0,1,0,20).should == Matrix[ [1, 2] ]
+      @matrix.minor(1,20,1,1).should == Matrix[ [4], [6] ]
+    end
+  end
+
+  describe "with col_range, row_range" do
+    it "returns the given portion of the Matrix" do
+      @matrix.minor(0..0, 0..1).should == Matrix[ [1, 2] ]
+      @matrix.minor(1..2, 1..2).should == Matrix[ [4], [6] ]
+      @matrix.minor(1...3, 1...3).should == Matrix[ [4], [6] ]
+    end
+
+    ruby_bug "redmine:1532", "1.8.7" do
+      it "returns nil if col_range or row_range is out of range" do
+        r = @matrix.row_size + 1
+        c = @matrix.column_size + 1
+        @matrix.minor(r..6, c..6).should == nil
+        @matrix.minor(0..1, c..6).should == nil
+        @matrix.minor(r..6, 0..1).should == nil
+        @matrix.minor(-r..6, -c..6).should == nil
+        @matrix.minor(0..1, -c..6).should == nil
+        @matrix.minor(-r..6, 0..1).should == nil
+      end
+
+      it "start counting backwards for col_range or row_range below zero" do
+        @matrix.minor(0..1, -2..-1).should == @matrix.minor(0..1, 0..1)
+        @matrix.minor(0..1, -2..1).should == @matrix.minor(0..1, 0..1)
+        @matrix.minor(-2..-1, 0..1).should == @matrix.minor(1..2, 0..1)
+        @matrix.minor(-2..2, 0..1).should == @matrix.minor(1..2, 0..1)
+      end
+    end
+  end
+
+  ruby_bug "redmine #5307", "1.9.3" do
+    describe "for a subclass of Matrix" do
+      it "returns an instance of that subclass" do
+        MatrixSub.ins.minor(0, 1, 0, 1).should be_an_instance_of(MatrixSub)
+      end
+    end
+  end
+end

data/spec/minus_spec.rb

@@ -0,0 +1,45 @@
+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] ]
+  end
+
+  it "returns the result of subtracting the corresponding elements of other from self" do
+    (@a - @b).should == Matrix[ [-3,-3], [-3,-3] ]
+  end
+
+  it "returns an instance of Matrix" do
+    (@a - @b).should be_kind_of(Matrix)
+  end
+
+  it "raises a Matrix::ErrDimensionMismatch if the matrices are different sizes" do
+    lambda { @a - Matrix[ [1] ] }.should raise_error(Matrix::ErrDimensionMismatch)
+  end
+
+  it "raises a ExceptionForMatrix::ErrOperationNotDefined if other is a Numeric Type" do
+    lambda { @a - 2            }.should raise_error(Matrix::ErrOperationNotDefined)
+    lambda { @a - 1.2          }.should raise_error(Matrix::ErrOperationNotDefined)
+    lambda { @a - bignum_value }.should raise_error(Matrix::ErrOperationNotDefined)
+  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
+
+  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)
+      end
+    end
+  end
+end

data/spec/multiply_spec.rb

@@ -0,0 +1,73 @@
+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] ]
+  end
+
+  it "returns the result of multiplying the corresponding elements of self and a Matrix" do
+    (@a * @b).should == Matrix[ [16,19], [36,43] ]
+  end
+
+  it "returns the result of multiplying the corresponding elements of self and a Vector" do
+    (@a * Vector[1,2]).should == Vector[5, 11]
+  end
+
+  it "returns the result of multiplying the elements of self and a Fixnum" do
+    (@a * 2).should == Matrix[ [2, 4], [6, 8] ]
+  end
+
+  it "returns the result of multiplying the elements of self and a Bignum" do
+    (@a * bignum_value).should == Matrix[
+      [9223372036854775808, 18446744073709551616],
+      [27670116110564327424, 36893488147419103232]
+    ]
+  end
+
+  it "returns the result of multiplying the elements of self and a Float" do
+    (@a * 2.0).should == Matrix[ [2.0, 4.0], [6.0, 8.0] ]
+  end
+
+  it "raises a Matrix::ErrDimensionMismatch if the matrices are different sizes" do
+    lambda { @a * Matrix[ [1] ] }.should raise_error(Matrix::ErrDimensionMismatch)
+  end
+
+  ruby_bug "redmine:1532", "1.8.7" do
+    it "returns a zero matrix if (nx0) * (0xn)" do
+      (Matrix[[],[],[]] * Matrix.columns([[],[],[]])).should == Matrix.zero(3)
+    end
+
+    it "returns an empty matrix if (0xn) * (nx0)" do
+      (Matrix.columns([[],[],[]]) * Matrix[[],[],[]]).should == Matrix[]
+    end
+
+    it "returns a mx0 matrix if (mxn) * (nx0)" do
+      (Matrix[[1,2],[3,4],[5,6]] * Matrix[[],[]]).should == Matrix[[],[],[]]
+    end
+
+    it "returns a 0xm matrix if (0xm) * (mxn)" do
+      (Matrix.columns([[], [], []]) * Matrix[[1,2],[3,4],[5,6]]).should == Matrix.columns([[],[]])
+    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
+
+  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
+end

data/spec/new_spec.rb

@@ -0,0 +1,7 @@
+require 'matrix'
+
+describe "Matrix.new" do
+  it "is private" do
+    Matrix.should have_private_method(:new)
+  end
+end

data/spec/normal_spec.rb

@@ -0,0 +1,27 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix.normal?" do
+    # it "returns false for non normal matrices" do
+    #   Matrix[[0, 1], [1, 2]].normal?.should == false
+    # end
+  
+    it "returns true for normal matrices" do
+      Matrix[[1, 1, 0], [0, 1, 1], [1, 0, 1]].normal?.should == true
+      Matrix[[0, Complex(0, 2)], [Complex(0, -2), 0]].normal?.should == true
+    end
+
+    it "raises an error for rectangular matrices" do
+      [
+        Matrix[[0], [0]],
+        Matrix[[0, 0]],
+        Matrix.empty(0, 2),
+        Matrix.empty(2, 0),
+      ].each do |rectangual_matrix|
+        lambda {
+          rectangual_matrix.normal?
+        }.should raise_error(Matrix::ErrDimensionMismatch)
+      end
+    end
+  end
+end

data/spec/orthogonal_spec.rb

@@ -0,0 +1,27 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix.orthogonal?" do
+    it "returns false for non orthogonal matrices" do
+      Matrix[[0, 1], [1, 2]].orthogonal?.should == false
+      Matrix[[1, 1, 0], [0, 1, 1], [1, 0, 1]].orthogonal?.should == false
+    end
+  
+    it "returns true for orthogonal matrices" do
+      Matrix[[0, 1], [1, 0]].orthogonal?.should == true
+    end
+
+    it "raises an error for rectangular matrices" do
+      [
+        Matrix[[0], [0]],
+        Matrix[[0, 0]],
+        Matrix.empty(0, 2),
+        Matrix.empty(2, 0),
+      ].each do |rectangual_matrix|
+        lambda {
+          rectangual_matrix.orthogonal?
+        }.should raise_error(Matrix::ErrDimensionMismatch)
+      end
+    end
+  end
+end

data/spec/permutation_spec.rb

@@ -0,0 +1,33 @@
+require 'matrix'
+
+ruby_version_is "1.9.3" do
+  describe "Matrix#permutation?" do
+    it "returns true for a permutation Matrix" do
+      Matrix[[0, 1, 0], [0, 0, 1], [1, 0, 0]].permutation?.should be_true
+    end
+
+    it "returns false for a non permutation square Matrix" do
+      Matrix[[0, 1], [0, 0]].permutation?.should be_false
+      Matrix[[-1, 0], [0, -1]].permutation?.should be_false
+      Matrix[[1, 0], [1, 0]].permutation?.should be_false
+      Matrix[[1, 0], [1, 1]].permutation?.should be_false
+    end
+
+    it "returns true for an empty 0x0 matrix" do
+      Matrix.empty(0,0).permutation?.should be_true
+    end
+
+    it "raises an error for rectangular matrices" do
+      [
+        Matrix[[0], [0]],
+        Matrix[[0, 0]],
+        Matrix.empty(0, 2),
+        Matrix.empty(2, 0),
+      ].each do |rectangual_matrix|
+        lambda {
+          rectangual_matrix.permutation?
+        }.should raise_error(Matrix::ErrDimensionMismatch)
+      end
+    end
+  end
+end