nmatrix 0.0.8 → 0.0.9

data/spec/math_spec.rb

@@ -53,7 +53,11 @@ describe "math" do
         begin
           a.invert!
         rescue NotImplementedError => e
-          pending e.to_s
+          if dtype.to_s =~ /rational/
+            pending "getri needs rational implementation"
+          else
+            pending e.to_s
+          end
         end
         a.should == b
       end
@@ -89,8 +93,8 @@ describe "math" do
                  MATRIX32A_ARRAY
                end
 
-        n = NMatrix.new([4,3], nary, left_dtype)
-        m = NMatrix.new([3,2], mary, right_dtype)
+        n = NMatrix.new([4,3], nary, dtype: left_dtype, stype: :dense)
+        m = NMatrix.new([3,2], mary, dtype: right_dtype, stype: :dense)
 
         m.shape[0].should == 3
         m.shape[1].should == 2
@@ -127,9 +131,9 @@ describe "math" do
       it "dense handles #{left_dtype.to_s} dot #{right_dtype.to_s} vector multiplication" do
         #STDERR.puts "dtype=#{dtype.to_s}"
         #STDERR.puts "2"
-        n = NMatrix.new([4,3], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0], left_dtype)
+        n = NMatrix.new([4,3], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0], dtype: left_dtype)
 
-        m = NVector.new(3, [2.0, 1.0, 0.0], right_dtype).transpose
+        m = NMatrix.new([3,1], [2.0, 1.0, 0.0], dtype: right_dtype)
 
         m.shape[0].should == 3
         m.shape[1].should == 1

data/spec/nmatrix_yale_spec.rb

@@ -28,21 +28,17 @@ require "./lib/nmatrix"
 
 describe NMatrix do
   context :yale do
-    it "calculates itype" do
-      NMatrix.itype_by_shape([4,4]).should == :uint8
-      NMatrix.itype_by_shape(4).should == :uint8
-      ## FIXME: Check larger shapes for correct itype
-    end
 
     it "compares two empty matrices" do
-      n = NMatrix.new(:yale, [4,4], :float64)
-      m = NMatrix.new(:yale, [4,4], :float64)
+      n = NMatrix.new(4, stype: :yale, dtype: :float64)
+      m = NMatrix.new(4, stype: :yale, dtype: :float64)
       n.should == m
     end
 
     it "compares two matrices following basic assignments" do
-      n = NMatrix.new(:yale, [2,2], :float64)
-      m = NMatrix.new(:yale, [2,2], :float64)
+      n = NMatrix.new(2, stype: :yale, dtype: :float64)
+      m = NMatrix.new(2, stype: :yale, dtype: :float64)
+
       m[0,0] = 1
       m[0,1] = 1
       n.should_not == m
@@ -53,15 +49,16 @@ describe NMatrix do
     end
 
     it "compares two matrices following elementwise operations" do
-      n = NMatrix.new(:yale, [2,2], :float64)
+      n = NMatrix.new(2, stype: :yale, dtype: :float64)
+      m = NMatrix.new(2, stype: :yale, dtype: :float64)
       n[0,1] = 1
-      m = NMatrix.new(:yale, [2,2], :float64)
       m[0,1] = -1
-      (n+m).should == NMatrix.new(:yale, [2,2], :float64)
+      x = n+m
+      (n+m).should == NMatrix.new(2, 0.0, stype: :yale)
     end
 
     it "sets diagonal values" do
-      n = NMatrix.new(:yale, [2,3], :float64)
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[1,1] = 0.1
       n[0,0] = 0.2
@@ -69,7 +66,7 @@ describe NMatrix do
     end
 
     it "gets non-diagonal rows as hashes" do
-      n = NMatrix.new(:yale, [4,6], :float64)
+      n = NMatrix.new([4,6], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[0,0] = 0.1
       n[0,2] = 0.2
@@ -80,7 +77,7 @@ describe NMatrix do
     end
 
     it "gets non-diagonal occupied column indices for a given row" do
-      n = NMatrix.new(:yale, [4,6], :float64)
+      n = NMatrix.new([4,6], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[0,0] = 0.1
       n[0,2] = 0.2
@@ -91,7 +88,7 @@ describe NMatrix do
     end
 
     it "does not resize until necessary" do
-      n = NMatrix.new(:yale, [2,3], :float64)
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n.yale_size.should == 3
       n.capacity.should == 5
@@ -104,7 +101,7 @@ describe NMatrix do
 
 
     it "sets when not resizing" do
-      n = NMatrix.new(:yale, [2,3], :float64)
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[0,0] = 0.1
       n[0,1] = 0.2
@@ -114,7 +111,7 @@ describe NMatrix do
     end
 
     it "sets when resizing" do
-      n = NMatrix.new(:yale, [2,3], :float64)
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[0,0] = 0.01
       n[1,1] = 0.1
@@ -132,7 +129,8 @@ describe NMatrix do
 
       associations = File.open('spec/nmatrix_yale_resize_test_associations.yaml') { |y| YAML::load(y) }
 
-      n = NMatrix.new(:yale, [618, 2801], associations.size, :byte)
+      n = NMatrix.new([618,2801], stype: :yale, dtype: :byte, capacity: associations.size)
+      #n = NMatrix.new(:yale, [618, 2801], associations.size, :byte)
 
       associations.each_pair do |j,i|
         n[i,j] = 1
@@ -145,7 +143,7 @@ describe NMatrix do
     end
 
     it "sets values within rows" do
-      n = NMatrix.new(:yale, [3,20], :float64)
+      n = NMatrix.new([3,20], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[2,1]   = 1.0
       n[2,0]   = 1.5
@@ -155,7 +153,7 @@ describe NMatrix do
     end
 
     it "gets values within rows" do
-      n = NMatrix.new(:yale, [3,20], :float64)
+      n = NMatrix.new([3,20], stype: :yale, dtype: :float64)
       n[2,1]   = 1.0
       n[2,0]   = 1.5
       n[2,15]  = 2.0
@@ -165,7 +163,7 @@ describe NMatrix do
     end
 
     it "sets values within large rows" do
-      n = NMatrix.new(:yale, [10,300], :float64)
+      n = NMatrix.new([10,300], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[5,1]   = 1.0
       n[5,0]   = 1.5
@@ -182,7 +180,7 @@ describe NMatrix do
     end
 
     it "gets values within large rows" do
-      n = NMatrix.new(:yale, [10,300], :float64)
+      n = NMatrix.new([10,300], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
       n[5,1]   = 1.0
       n[5,0]   = 1.5
@@ -202,7 +200,7 @@ describe NMatrix do
     end
 
     it "dots two identical matrices" do
-      a = NMatrix.new(:yale, 4, :float64)
+      a = NMatrix.new(4, stype: :yale, dtype: :float64)
       a[0,1] = 4.0
       a[1,2] = 1.0
       a[1,3] = 1.0
@@ -211,26 +209,13 @@ describe NMatrix do
       b = a.dup
       c = a.dot b
 
-      c[0,0].should == 0.0
-      c[0,1].should == 0.0
-      c[0,2].should == 4.0
-      c[0,3].should == 4.0
-      c[1,0].should == 0.0
-      c[1,1].should == 2.0
-      c[1,2].should == 0.0
-      c[1,3].should == 0.0
-      c[2,0].should == 0.0
-      c[2,1].should == 0.0
-      c[2,2].should == 0.0
-      c[2,3].should == 0.0
-      c[3,0].should == 0.0
-      c[3,1].should == 0.0
-      c[3,2].should == 2.0
-      c[3,3].should == 2.0
+      d = NMatrix.new(4, [0,0,4,4, 0,2,0,0, 0,0,0,0, 0,0,2,2], dtype: :float64, stype: :yale)
+
+      c.should == d
     end
 
     it "dots two identical matrices where a positive and negative partial sum cancel on the diagonal" do
-      a = NMatrix.new(:yale, 4, :float64)
+      a = NMatrix.new(4, 0.0, stype: :yale)
 
       a[0,0] = 1.0
       a[0,1] = 4.0
@@ -242,23 +227,6 @@ describe NMatrix do
       b = a.dup
       c = a.dot b
 
-      #c[0,0].should == 1.0
-      #c[0,1].should == 4.0
-      #c[0,2].should == 8.0
-      #c[0,3].should == -16.0
-      #c[1,0].should == 0.0
-      #c[1,1].should == -16.0
-      #c[1,2].should == 0.0
-      #c[1,3].should == -16.0
-      #c[2,0].should == 0.0
-      #c[2,1].should == 0.0
-      #c[2,2].should == 0.0
-      #c[2,3].should == 0.0
-      #c[3,0].should == 0.0
-      #c[3,1].should == 0.0
-      #c[3,2].should == 8.0
-      #c[3,3].should == 0.0 # this is the positive and negative partial sum cancel
-
       c.extend(NMatrix::YaleFunctions)
 
       c.yale_ija.reject { |i| i.nil? }.should == [5,8,9,9,11,1,2,3,3,1,2]
@@ -267,8 +235,8 @@ describe NMatrix do
     end
 
     it "dots two vectors" do
-      n = NVector.new(:yale, [16,1], :int64)
-      m = NVector.new(:yale, [1,16], :int64)
+      n = NMatrix.new([16,1], 0, stype: :yale)
+      m = NMatrix.new([1,16], 0, stype: :yale)
 
       n[0] = m[0] = 1
       n[1] = m[1] = 2
@@ -300,7 +268,7 @@ describe NMatrix do
     end
 
     it "transposes" do
-      a = NMatrix.new(:yale, 4, :float64)
+      a = NMatrix.new(4, 0.0, stype: :yale)
       a[0,0] = 1.0
       a[0,1] = 4.0
       a[1,2] = 2.0

data/spec/shortcuts_spec.rb

@@ -27,6 +27,7 @@
 
 # Can we use require_relative here instead?
 require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'pry'
 
 describe NMatrix do
 
@@ -89,26 +90,12 @@ describe NMatrix do
 
     2.times do |i|
       2.times do |j|
-        m[i, j].should == value
+        m[i,j].should == value
         value += 1
       end
     end
   end
 
-  it "seq() only accepts an integer or a 2-element array as dimension" do
-    m = NMatrix.seq([2, 2])
-    value = 0
-
-    2.times do |i|
-      2.times do |j|
-        m[i, j].should == value
-        value += 1
-      end
-    end
-
-    expect { NMatrix.seq([1, 2, 3]) }.to raise_error
-    expect { NMatrix.seq("not an array or integer") }.to raise_error
-  end
 
   it "indgen() creates a matrix of integers as well as seq()" do
     m = NMatrix.indgen(2) # 2x2 matrix.
@@ -186,6 +173,31 @@ describe NMatrix do
     m[3,3].should eq(arr[3])
   end
 
+  context "_like constructors" do
+    before :each do
+      STDERR.puts "starting GC"
+      GC.start
+      STDERR.puts "GC finished"
+      @nm_1d = NMatrix[5.0,0.0,1.0,2.0,3.0]
+      STDERR.puts "@nm_1d"
+      @nm_2d = NMatrix[[0.0,1.0],[2.0,3.0]]
+      STDERR.puts "@nm_2d"
+    end
+
+    it "should create an nmatrix of ones with dimensions and type the same as its argument" do
+      NMatrix.ones_like(@nm_1d).should eq NMatrix[1.0, 1.0, 1.0, 1.0, 1.0]
+      NMatrix.ones_like(@nm_2d).should eq NMatrix[[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
+      STDERR.puts "A"
+      NMatrix.zeros_like(@nm_1d).should eq NMatrix[0.0, 0.0, 0.0, 0.0, 0.0]
+      STDERR.puts "B"
+      NMatrix.zeros_like(@nm_2d).should eq NMatrix[[0.0, 0.0], [0.0, 0.0]]
+      STDERR.puts "C"
+    end
+  end
+
 end
 
 describe "NVector" do
@@ -214,7 +226,7 @@ describe "NVector" do
 
   it "seq() creates a vector of integers, sequentially" do
     v = NVector.seq(7)
-    v.should == NVector.new(7, [0, 1, 2, 3, 4, 5, 6], :int64)
+    v.should == NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6])
   end
 
   it "seq() only accepts integers as dimension" do
@@ -226,32 +238,32 @@ describe "NVector" do
 
   it "indgen() creates a vector of integers as well as seq()" do
     v = NVector.indgen(7)
-    v.should == NVector.new(7, [0, 1, 2, 3, 4, 5, 6], :int64)
+    v.should == NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6])
   end
 
   it "findgen creates a vector of floats, sequentially" do
     v = NVector.findgen(2)
-    v.should == NVector.new(2, [0.0, 1.0], :float32)
+    v.should == NMatrix.new([2,1], [0.0, 1.0])
   end
 
   it "bindgen() creates a vector of bytes, sequentially" do
     v = NVector.bindgen(4)
-    v.should == NVector.new(4, [0, 1, 2, 3], :byte)
+    v.should == NMatrix.new([4,1], [0, 1, 2, 3], dtype: :byte)
   end
 
   it "cindgen() creates a vector of complexes, sequentially" do
     v = NVector.cindgen(2)
-    v.should == NVector.new(2, [Complex(0.0, 0.0), Complex(1.0, 0.0)], :complex64)
+    v.should == NMatrix.new([2,1], [Complex(0.0, 0.0), Complex(1.0, 0.0)], dtype: :complex64)
   end
 
   it "linspace() creates a vector with n values equally spaced between a and b" do
     v = NVector.linspace(0, 2, 5)
-    v.should == NVector.new(5, [0, 0.5, 1.0, 1.5, 2.0], :float64)
+    v.should == NMatrix.new([5,1], [0.0, 0.5, 1.0, 1.5, 2.0])
   end
 
   it "logspace() creates a vector with n values logarithmically spaced between decades 10^a and 10^b" do
     v = NVector.logspace(0, 3, 4)
-    v.should == NVector.new(4, [1, 10, 100, 1000], :float64)
+    v.should == NMatrix.new([4,1], [1.0, 10.0, 100.0, 1000.0])
   end
 end
 

data/spec/slice_set_spec.rb

@@ -0,0 +1,157 @@
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == slice_set_spec.rb
+#
+# Test of slice set operations.
+
+require 'pry'
+require File.dirname(__FILE__) + "/spec_helper.rb"
+
+describe "Set slice operation" do
+  include RSpec::Longrun::DSL
+
+  [:dense, :yale, :list].each do |stype|
+    context "for #{stype}" do
+      before :each do
+        @m = create_matrix(stype)
+      end
+
+      example "set and unset a range of entries with single values" do
+
+        if stype == :yale
+          step "verify correct arrangement of Yale IJA and A arrays" do
+            @m.extend NMatrix::YaleFunctions
+            @m.yale_ija.should == [4,6,8,10,1,2,0,2,0,1]
+            @m.yale_a.should   == [0,4,8,0, 1,2,3,5,6,7]
+          end
+        end
+
+        step "set and reset a single entry" do
+          n = @m.clone
+          old_val = @m[0,0]
+          @m[0,0] = 100
+          @m[0,0].should == 100
+          @m[0,0] = old_val
+          @m.should == n
+        end
+
+        if stype == :yale
+          n = @m.clone
+          step "set a row of entries" do
+            n[0,0..2] = 0
+            n[0,0..2].to_flat_array.should == [0,0,0]
+            n[1,0..2].to_flat_array.should == [3,4,5]
+            n[2,0..2].to_flat_array.should == [6,7,8]
+          end
+
+          step "set a second row of entries" do
+            n[2,0..2] = 0
+            n[2,0..2].to_flat_array.should == [0,0,0]
+            n[1,0..2].to_flat_array.should == [3,4,5]
+          end
+
+          step "reset both rows of entries" do
+            n[0,0..2] = [0,1,2]
+            n[2,0..2] = [6,7,8]
+            n.should == @m
+          end
+        end
+
+        slice_result_a = NMatrix.new(:dense, 2, 100, @m.dtype).cast(stype)
+        slice_result_b = NMatrix.new(:dense, 2, 0,   @m.dtype).cast(stype)
+        m = @m.clone
+
+        step "set upper left-hand 2x2 corner to 100" do
+          m[0..1,0..1] = 100
+
+          if stype == :yale
+            m.yale_ija.should == [4,   6,   8,   10,   1,   2,   0,   2,  0,  1]
+            m.yale_a.should   == [100, 100, 8,   0,   100,  2, 100,   5,  6,  7]
+          end
+
+          m[0..1,0..1].should == slice_result_a
+          m[2,0..1].should == @m[2,0..1]
+          m[0..1,2].should == @m[0..1,2]
+        end
+
+        step "set upper left-hand 2x2 corner to 0" do
+          m[0..1,0..1] = 0
+          if stype == :yale
+            [4,5,6,8,2,2,0,1].should == m.yale_ija
+            [0,0,8,0,2,5,6,7].should == m.yale_a
+          end
+
+          m[0..1,0..1].should == slice_result_b
+        end
+
+        m = @m.clone
+        step "set lower left-hand 2x2 corner to 100" do
+          m[1..2,0..1] = 100
+          m[1..2,0..1].should == slice_result_a
+          m[0,0..1].should == @m[0,0..1]
+          m[1..2,2].should == @m[1..2,2]
+        end
+
+        step "set lower left-hand 2x2 corner to 0" do
+          m[1..2,0..1] = 0
+          m[1..2,0..1].should == slice_result_b
+        end
+
+        m = @m.clone
+        step "set lower right-hand 2x2 corner to 100" do
+          m[1..2,1..2] = 100
+          m[1..2,1..2].should == slice_result_a
+          m[0,1..2].should == @m[0,1..2]
+          m[1..2,0].should == @m[1..2,0]
+        end
+
+        step "set lower right-hand 2x2 corner to 0" do
+          m[1..2,1..2] = 0
+          m[1..2,1..2].should == slice_result_b
+        end
+
+        m = @m.clone
+        step "set upper right-hand 2x2 corner to 100" do
+          m[0..1,1..2] = 100
+          m[0..1,1..2].should == slice_result_a
+          m[2,1..2].should == @m[2,1..2]
+          m[0..1,0].should == @m[0..1,0]
+        end
+
+        step "set upper right-hand 2x2 corner to 0" do
+          m[0..1,1..2] = 0
+          m[0..1,1..2].should == slice_result_b
+        end
+      end
+
+      example "set a range of values to a matrix's contents" do
+        x = NMatrix.new(4, stype: :yale, dtype: :int16)
+        x.extend NMatrix::YaleFunctions if stype == :yale
+        x[1..3,1..3] = @m
+        x.to_flat_array.should == [0,0,0,0, 0,0,1,2, 0,3,4,5, 0,6,7,8]
+      end
+
+    end
+  end
+
+end