nmatrix 0.0.5 → 0.0.6

data/lib/nmatrix/version.rb

@@ -26,6 +26,6 @@ class NMatrix
   # Note that the format of the VERSION string is needed for NMatrix
   # native IO. If you change the format, please make sure that native
   # IO can still understand NMatrix::VERSION.
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end
 

data/lib/nmatrix/yale_functions.rb

@@ -39,33 +39,36 @@ module NMatrix::YaleFunctions
   end
 
   # call-seq:
-  #     yale_nd_row_as_array -> Array
+  #     yale_ja_at(i) -> Array
   #
   # Returns the non-diagonal column indices which are stored in a given row.
-  def yale_nd_row_as_array i
-    yale_nd_row(i, :array)
+  def yale_ja_at i
+    yale_nd_row(i, :keys)
   end
+  alias :yale_nd_row_as_array :yale_ja_at
 
   # call-seq:
-  #     yale_nd_row_as_set -> Set
+  #     yale_ja_set_at(i) -> Set
   #
   # Returns the non-diagonal column indices which are stored in a given row, as a Set.
-  def yale_nd_row_as_set i
+  def yale_ja_set_at i
     require 'set'
-    yale_nd_row(i, :array).to_set
+    yale_nd_row(i, :keys).to_set
   end
+  alias :yale_nd_row_as_set :yale_ja_set_at
 
   # call-seq:
-  #     yale_nd_row_as_sorted_set -> SortedSet
+  #     yale_ja_sorted_set_at -> SortedSet
   #
   # Returns the non-diagonal column indices which are stored in a given row, as a Set.
-  def yale_nd_row_as_sorted_set i
+  def yale_ja_sorted_set_at i
     require 'set'
-    SortedSet.new(yale_nd_row(i, :array))
+    SortedSet.new(yale_nd_row(i, :keys))
   end
+  alias :yale_nd_row_as_sorted_set :yale_ja_sorted_set_at
 
   # call-seq:
-  #     yale_nd_row_as_hash -> Hash
+  #     yale_nd_row_as_hash(i) -> Hash
   #
   # Returns the non-diagonal column indices and entries stored in a given row.
   def yale_nd_row_as_hash i
@@ -73,35 +76,38 @@ module NMatrix::YaleFunctions
   end
 
   # call-seq:
-  #     yale_row_as_array -> Array
+  #     yale_ja_d_keys_at(i) -> Array
   #
   # Returns the diagonal and non-digonal column indices stored in a given row.
-  def yale_row_as_array i
-    ary = yale_nd_row(i, :array)
+  def yale_ja_d_keys_at i
+    ary = yale_nd_row(i, :keys)
     return ary if i >= self.shape[1] || self[i,i].nil? || self[i,i] == 0
     ary << i
   end
+  alias :yale_row_as_array :yale_ja_d_keys_at
 
   # call-seq:
-  #     yale_row_as_set -> Set
+  #     yale_ja_d_keys_set_at(i) -> Set
   #
   # Returns the diagonal and non-diagonal column indices stored in a given row.
-  def yale_row_as_set i
+  def yale_ja_d_keys_set_at i
     require 'set'
-    yale_row_as_array(i).to_set
+    yale_ja_d_keys_at(i).to_set
   end
+  alias :yale_row_as_set :yale_ja_d_keys_set_at
 
   # call-seq:
-  #     yale_row_as_sorted_set -> SortedSet
+  #     yale_ja_d_keys_sorted_set_at(i) -> SortedSet
   #
   # Returns the diagonal and non-diagonal column indices stored in a given row.
-  def yale_row_as_sorted_set i
+  def yale_ja_d_keys_sorted_set_at i
     require 'set'
     SortedSet.new(yale_row_as_array(i))
   end
+  alias :yale_row_as_sorted_set :yale_ja_d_keys_sorted_set_at
 
   # call-seq:
-  #     yale_row_as_hash -> Hash
+  #     yale_row_as_hash(i) -> Hash
   #
   # Returns the diagonal and non-diagonal column indices and entries stored in a given row.
   def yale_row_as_hash i

data/spec/blas_spec.rb

@@ -67,23 +67,6 @@ describe NMatrix::BLAS do
 
   [:float32, :float64].each do |dtype|
     context dtype do
-      it "exposes unfriendly cblas_rot" do
-        x = NVector.new(5, [1,2,3,4,5], dtype)
-        y = NVector.new(5, [-5,-4,-3,-2,-1], dtype)
-        NMatrix::BLAS::cblas_rot(5, x, 1, y, -1, 0.5, Math.sqrt(3)/2)
-
-        x[0].should be_within(1e-4).of(-0.3660254037844386)
-        x[1].should be_within(1e-4).of(-0.7320508075688772)
-        x[2].should be_within(1e-4).of(-1.098076211353316)
-        x[3].should be_within(1e-4).of(-1.4641016151377544)
-        x[4].should be_within(1e-4).of(-1.8301270189221928)
-
-        y[0].should be_within(1e-4).of(-6.830127018922193)
-        y[1].should be_within(1e-4).of(-5.464101615137754)
-        y[2].should be_within(1e-4).of(-4.098076211353316)
-        y[3].should be_within(1e-4).of(-2.732050807568877)
-        y[4].should be_within(1e-4).of(-1.3660254037844386)
-      end
 
       it "exposes cblas rot" do
         x = NVector.new(5, [1,2,3,4,5], dtype)
@@ -103,10 +86,9 @@ describe NMatrix::BLAS do
         y[4].should be_within(1e-4).of(-1.3660254037844386)
       end
 
-      # FIXME: Need to write new Rational algorithm, which doesn't choke quite so often on irrational square roots (which often eventually cancel).
       it "exposes cblas rotg" do
         ab = NVector.new(2, [6,-8], dtype)
-        c,s = NMatrix::BLAS::cblas_rotg(ab)
+        c,s = NMatrix::BLAS::rotg(ab)
         ab[0].should be_within(1e-6).of(-10)
         ab[1].should be_within(1e-6).of(-5.quo(3))
         c.should be_within(1e-6).of(-3.quo(5))

data/spec/elementwise_spec.rb

@@ -30,6 +30,95 @@ require File.join(File.dirname(__FILE__), "spec_helper.rb")
 
 describe NMatrix do
 
+  context "yale" do
+    before :each do
+      @n = NMatrix.new(:yale, 3, :int64)
+      @m = NMatrix.new(:yale, 3, :int64)
+      @n[0,0] = 52
+      @n[0,2] = 5
+      @n[1,1] = 40
+      @n[0,1] = 30
+      @n[2,0] = 6
+      @m[1,1] = -48
+      @m[0,2] = -5
+      @n.extend NMatrix::YaleFunctions
+    end
+
+    it "should perform scalar math" do
+      x = @n * 3
+      x[0,0].should == 52 * 3
+      x[0,1].should == 30 * 3
+      x[0,2].should == 5 * 3
+      x[1,1].should == 40 * 3
+      x[2,0].should == 6 * 3
+
+      r = NMatrix.new(:yale, 3, :int64)
+      y = r + 3
+      y[0,0].should == 3
+    end
+
+    it "should refuse to perform a dot operation on a yale with non-zero default" do
+      r = NMatrix.new(:yale, 3, :int64)
+      y = r + 3
+      expect { y.dot(r) }.to raise_error
+      expect { r.dot(y) }.to raise_error
+    end
+
+    it "should perform element-wise addition" do
+      r = NMatrix.new(:dense, 3, [52,30,0,0,-8,0,6,0,0], :int64).cast(:yale, :int64)
+      r[0,0] = 52
+      r[1,1] = -8
+      q = @n + @m
+      q.should == r
+    end
+
+    it "should perform element-wise subtraction" do
+      (@n-@m).should == NMatrix.new(:dense, 3, [52,30,10,0,88,0,6,0,0], :int64).cast(:yale, :int64)
+    end
+
+    it "should perform element-wise multiplication" do
+      r = NMatrix.new(:dense, 3, [0,0,-25,0,-1920,0,0,0,0], :int64).cast(:yale, :int64)
+      m = NMatrix.new(:yale, 2, :int64)
+      (@n*@m).should == r
+    end
+
+    it "should perform element-wise division" do
+      r = NMatrix.new(:dense, 3, [52, 30, -2, 0, -1, 0, 6, 0, 0], :int64).cast(:yale, :int64)
+      (@n/(@m+1)).should == r
+    end
+
+    it "should perform element-wise modulo" do
+      m = NMatrix.new(:yale, 3, :int64) + 5
+      (@n % m).should == NMatrix.new(:dense, 3, [2,0,0,0,0,0,1,0,0], :int64).cast(:yale, :int64)
+    end
+
+    it "should handle element-wise equality (=~)" do
+      (@n =~ @m).should == NMatrix.new(:dense, 3, [false,false,false,true,false,true,false,true,true], :object).cast(:yale, :object, false)
+    end
+
+    it "should handle element-wise inequality (!~)" do
+      (@n !~ @m).should == NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, true)
+    end
+
+    it "should handle element-wise less-than (<)" do
+      (@m < @n).should == NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, true)
+    end
+
+    it "should handle element-wise greater-than (>)" do
+      (@n > @m).should == NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, false)
+    end
+
+    it "should handle element-wise greater-than-or-equals (>=)" do
+      (@n >= @m).should == NMatrix.new(:dense, 3, true, :object).cast(:yale,:object, true)
+    end
+
+    it "should handle element-wise less-than-or-equals (<=)" do
+      r = NMatrix.new(:dense, 3, [false,false,false,true,false,true,false,true,true], :object).cast(:yale, :object, false)
+      (@n <= @m).should == r
+    end
+  end
+
+
   context "list" do
     before :each do
       @n = NMatrix.new(:list, 2, 0, :int64)
@@ -51,12 +140,15 @@ describe NMatrix do
     end
 
     it "should perform element-wise addition" do
-      r = NMatrix.new(:dense, 2, [52, 0, 0, -8], :int64).cast(:list, :int64)
-      (@n+@m).should == r
+      r = NMatrix.new(:list, 2, 0, :int64)
+      r[0,0] = 52
+      r[1,1] = -8
+      q = @n + @m
+      q.should == r
     end
 
     it "should perform element-wise subtraction" do
-      r = NMatrix.new(:dense, 2, [52, 0, 0, -88], :int64).cast(:list, :int64)
+      r = NMatrix.new(:dense, 2, [52, 0, 0, 88], :int64).cast(:list, :int64)
       (@n-@m).should == r
     end
 
@@ -75,31 +167,48 @@ describe NMatrix do
     end
 
     it "should perform element-wise modulo" do
-      pending "% operator not yet implemented for matrices"
+      m = NMatrix.new(:list, 2, 1, :int64)
+      m[0,0] = 50
+      m[1,1] = 40
+      (@n % m)
     end
 
     it "should handle element-wise equality (=~)" do
-      (@n =~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,1] = true
+      r[1,0] = true
+
+      (@n =~ @m).should == r
     end
 
     it "should handle element-wise inequality (!~)" do
-      (@n !~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [1, 0, 0, 1], :byte)
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,0] = true
+      r[1,1] = true
+
+      (@n !~ @m).should == r
     end
 
     it "should handle element-wise less-than (<)" do
-      (@n < @m).should == NMatrix.new(:list, 2, 0, :byte)
+      (@n < @m).should == NMatrix.new(:list, 2, false, :object)
     end
 
     it "should handle element-wise greater-than (>)" do
-      (@n > @m).should == NMatrix.new(:dense, 2, [1, 0, 0, 1], :byte).cast(:list, :byte)
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,0] = true
+      r[1,1] = true
+      (@n > @m).should == r
     end
 
     it "should handle element-wise greater-than-or-equals (>=)" do
-      (@n >= @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [1, 1, 1, 1], :byte)
+      (@n >= @m).should == NMatrix.new(:list, 2, true, :object)
     end
 
     it "should handle element-wise less-than-or-equals (<=)" do
-      (@n <= @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,1] = true
+      r[1,0] = true
+      (@n <= @m).should == r
     end
   end
 
@@ -132,6 +241,12 @@ describe NMatrix do
         r.should == NMatrix.new(:dense, [2,2], [-1, -2, 1, 0], :int64)
       end
 
+      #it "exponentiates" do
+      #  r = @n ** 2
+      #  # TODO: We might have problems with the dtype.
+      #  r.should == NMatrix.new(:dense, [2,2], [1, 4, 9, 16], :int64)
+      #end
+
       it "modulo" do
         pending "% operator not yet implemented"
         r = @n % @m
@@ -147,33 +262,33 @@ describe NMatrix do
 
       it "equals" do
         r = @n =~ @m
-        r.should == NMatrix.new(:dense, [2,2], [0, 0, 1, 0], :byte)
+        r.should == NMatrix.new(:dense, [2,2], [false, false, true, false], :object)
       end
 
       it "is not equal" do
         r = @n !~ @m
-        r.should == NMatrix.new(:dense, [2,2], [1, 1, 0, 1], :byte)
+        r.should == NMatrix.new(:dense, [2,2], [true, true, false, true], :object)
       end
 
       it "is less than" do
         r = @n < @m
-        r.should == NMatrix.new(:dense, [2,2], 0, :byte)
+        r.should == NMatrix.new(:dense, [2,2], false, :object)
       end
 
       it "is greater than" do
         r = @n > @m
-        r.should == NMatrix.new(:dense, [2,2], [1, 1, 0, 1], :byte)
+        r.should == NMatrix.new(:dense, [2,2], [true, true, false, true], :object)
       end
 
       it "is less than or equal to" do
         r = @n <= @m
-        r.should == NMatrix.new(:dense, [2,2], [0, 0, 1, 0], :byte)
+        r.should == NMatrix.new(:dense, [2,2], [false, false, true, false], :object)
       end
 
       it "is greater than or equal to" do
-        n = NMatrix.new(:dense, [2,2], [ 1,  2, 2, 4], :int64)
+        n = NMatrix.new(:dense, [2,2], [1, 2, 2, 4], :int64)
         r = n >= @m
-        r.should == NMatrix.new(:dense, [2,2], [1, 1, 0, 1], :byte)
+        r.should == NMatrix.new(:dense, [2,2], [true, true, false, true], :object)
       end
     end
   end

data/spec/lapack_spec.rb

@@ -67,9 +67,6 @@ describe NMatrix::LAPACK do
         a[2,0].should == 1 # 3.quo(8)
         a[2,1].should be_within(err).of(52.quo(9))
         a[2,2].should be_within(err).of(360.quo(53))
-        # FIXME: these are rounded, == won't work
-        #a[2,1].should == 0.544118
-        #a[2,2].should == 5.294118
       end
 
       it "exposes clapack potrf" do

data/spec/nmatrix_list_spec.rb

@@ -43,6 +43,24 @@ describe NMatrix do
       n.should == m
     end
 
+    it "should compare 0-1 matrices with different default values with ==" do
+      n = NMatrix.new(:list, 2, 0, :object)
+      n[0,1] = 1
+      n[1,0] = 1
+
+      m = NMatrix.new(:list, 2, 1, :object)
+      m[0,0] = 0
+      m[1,1] = 0
+
+      n.should == m
+    end
+
+    it "should allow creation of both true- and false-based matrix" do
+      r1 = NMatrix.new(:list, 2, false, :object)
+      r2 = NMatrix.new(:list, 2, true, :object)
+      r1.should_not == r2
+    end
+
     it "should handle missing default value" do
       NMatrix.new(:list, 3, :int8)[0,0].should    == 0
       NMatrix.new(:list, 4, :float64)[0,0].should == 0.0

data/spec/nmatrix_spec.rb

@@ -31,7 +31,7 @@ describe NMatrix do
 
   it "calculates exact determinants on small square matrices" do
     a = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
-    x = a.det_exact
+    a.det_exact.should == -2
   end
 
   it "calculates determinants" do
@@ -39,11 +39,23 @@ describe NMatrix do
     m.det.should == 6
   end
 
+  it "allows casting to Ruby objects" do
+    m = NMatrix.new(:dense, [3,3], [0,0,1,0,2,0,3,4,5], :int64)
+    n = m.cast(:dense, :object)
+    n.should == m
+  end
+
+  it "allows casting from Ruby objects" do
+    m = NMatrix.new(:dense, [3,3], [0,0,1,0,2,0,3,4,5], :object)
+    n = m.cast(:dense, :int64)
+    m.should == n
+  end
+
   it "allows stype casting of a dim 2 matrix between dense, sparse, and list (different dtypes)" do
     m = NMatrix.new(:dense, [3,3], [0,0,1,0,2,0,3,4,5], :int64).
       cast(:yale, :int32).
       cast(:dense, :float64).
-      cast(:list, :int32).
+      cast(:list, :object).
       cast(:dense, :int16).
       cast(:list, :int32).
       cast(:yale, :int64) #.
@@ -185,14 +197,31 @@ describe NMatrix do
         c = dtype == :object ? "Ruby object" : "non-Ruby object"
         context c do
           it "allows iteration of matrices" do
-            pending("yale and list not implemented yet") unless storage_type == :dense
-            n = NMatrix.new(:dense, [3,3], [1,2,3,4,5,6,7,8,9], dtype)
+            n = nil
+            if storage_type == :dense
+              n = NMatrix.new(:dense, [3,3], [1,2,3,4,5,6,7,8,9], dtype)
+            else
+              n = storage_type == :yale ? NMatrix.new(storage_type, [3,4], dtype) : NMatrix.new(storage_type, [3,4], 0, dtype)
+              n[0,0] = 1
+              n[0,1] = 2
+              n[2,3] = 4
+              n[2,0] = 3
+            end
+            ary = []
             n.each do |x|
-              puts x
+              ary << x
+            end
+
+            if storage_type == :dense
+              ary.should == [1,2,3,4,5,6,7,8,9]
+            else
+              ary.should == [1,2,0,0,0,0,0,0,3,0,0,4]
             end
           end
 
           it "allows storage-based iteration of matrices" do
+            STDERR.puts storage_type.inspect
+            STDERR.puts dtype.inspect
             n = storage_type == :yale ? NMatrix.new(storage_type, [3,3], dtype) : NMatrix.new(storage_type, [3,3], 0, dtype)
             n[0,0] = 1
             n[0,1] = 2
@@ -297,7 +326,7 @@ describe NMatrix do
       val = (a.each { })
       val.should eq a
     end
-    
+
     it "should return the matrix being iterated over when each_stored_with_indices is called with a block" do
       a = NMatrix.new(2,1)
       val = (a.each_stored_with_indices { })
@@ -321,13 +350,13 @@ describe NMatrix do
 
     end
   end
-      
+
   it "should iterate through element 256 without a segfault" do
     t = NVector.random(256)
     t.each { |x| x + 0 }
   end
 
-  context "mapping and reduction related functions" do 
+  context "mapping and reduction related functions" do
 
     before :each do
       @nm_1d = N[5.0,0.0,1.0,2.0,3.0]
@@ -344,7 +373,7 @@ describe NMatrix do
       @nm_2d.mean.should eq N[[1.0,2.0]]
     end
 
-    it "should calculate the minimum along the specified dimension" do 
+    it "should calculate the minimum along the specified dimension" do
       @nm_1d.min.should eq 0.0
       @nm_2d.min.should eq N[[0.0, 1.0]]
       @nm_2d.min(1).should eq N[[0.0], [2.0]]
@@ -370,11 +399,11 @@ describe NMatrix do
       @nm_2d.std(1).should eq N[[Math.sqrt(0.5)], [Math.sqrt(0.5)]]
     end
 
-    it "should raise an ArgumentError when any invalid dimension is provided" do 
+    it "should raise an ArgumentError when any invalid dimension is provided" do
       expect { @nm_1d.mean(3) }.to raise_exception(ArgumentError)
     end
 
-    it "should convert to float if it contains only a single element" do 
+    it "should convert to float if it contains only a single element" do
       N[4.0].to_f.should eq 4.0
       N[[[[4.0]]]].to_f.should eq 4.0
     end
@@ -383,7 +412,7 @@ describe NMatrix do
       expect { @nm_1d.to_f }.to raise_error(IndexError)
     end
 
-    it "should map a block to all elements" do 
+    it "should map a block to all elements" do
       @nm_1d.map { |e| e ** 2 }.should eq N[25.0,0.0,1.0,4.0,9.0]
       @nm_2d.map { |e| e ** 2 }.should eq N[[0.0,1.0],[4.0,9.0]]
     end
@@ -478,12 +507,12 @@ describe NMatrix do
 
     it "should convert integer dtypes to float when calculating variance" do
       m = N[[1,2,3], [3,4,5], :int32]
-      m.mean(0).dtype.should eq :float64
+      m.variance(0).dtype.should eq :float64
     end
 
     it "should convert integer dtypes to float when calculating standard deviation" do
       m = N[[1,2,3], [3,4,5], :int32]
-      m.mean(0).dtype.should eq :float64
+      m.std(0).dtype.should eq :float64
     end
 
     context "_like constructors" do
@@ -493,13 +522,10 @@ describe NMatrix do
         NMatrix.ones_like(@nm_2d).should eq N[[1.0, 1.0], [1.0, 1.0]]
       end
 
-      it "should create an nmatrix of zeros with dimensions and type the same as its argument" do 
+      it "should create an nmatrix of zeros with dimensions and type the same as its argument" do
         NMatrix.zeros_like(@nm_1d).should eq N[0.0, 0.0, 0.0, 0.0, 0.0]
         NMatrix.zeros_like(@nm_2d).should eq N[[0.0, 0.0], [0.0, 0.0]]
       end
-
     end
-
   end
-  
 end