nmatrix 0.0.1 → 0.0.2

data/spec/math_spec.rb

@@ -0,0 +1,96 @@
+# = 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
+#
+# == math_spec.rb
+#
+# Tests for non-BLAS and non-LAPACK math functions, or for simplified
+# versions of unfriendly BLAS and LAPACK functions.
+#
+
+# Can we use require_relative here instead?
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe "math" do
+
+  [:float32, :float64, :complex64, :complex128, :rational32, :rational64, :rational128].each do |dtype|
+    context dtype do
+      it "should correctly factorize a matrix" do
+        m = NMatrix.new(:dense, 3, [4,9,2,3,5,7,8,1,6], dtype)
+        a = m.factorize_lu
+        a[0,0].should == 8
+        a[0,1].should == 1
+        a[0,2].should == 6
+        a[1,0].should == 0.5
+        a[1,1].should == 8.5
+        a[1,2].should == -1
+        a[2,0].should == 0.375
+      end
+    end
+  end
+
+  [:float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+
+      # Note: this exposes gemm, not cblas_gemm (which is the unfriendly CBLAS no-error-checking version)
+      it "exposes gemm" do
+        #STDERR.puts "dtype=#{dtype.to_s}"
+        #STDERR.puts "1"
+        n = NMatrix.new([4,3], dtype)
+        n[0,0] = 14.0
+        n[0,1] = 9.0
+        n[0,2] = 3.0
+        n[1,0] = 2.0
+        n[1,1] = 11.0
+        n[1,2] = 15.0
+        n[2,0] = 0.0
+        n[2,1] = 12.0
+        n[2,2] = 17.0
+        n[3,0] = 5.0
+        n[3,1] = 2.0
+        n[3,2] = 3.0
+
+        m = NMatrix.new([3,2], dtype)
+
+        m[0,0] = 12.0
+        m[0,1] = 25.0
+        m[1,0] = 9.0
+        m[1,1] = 10.0
+        m[2,0] = 8.0
+        m[2,1] = 5.0
+
+        #c = NMatrix.new([4,2], dtype)
+        r = NMatrix::BLAS.gemm(n, m) #, c)
+        #c.should equal(r) # check that both are same memory address
+
+        r[0,0].should == 273.0
+        r[0,1].should == 455.0
+        r[1,0].should == 243.0
+        r[1,1].should == 235.0
+        r[2,0].should == 244.0
+        r[2,1].should == 205.0
+        r[3,0].should == 102.0
+        r[3,1].should == 160.0
+      end
+
+    end
+  end
+end

data/spec/nmatrix_spec.rb

@@ -24,20 +24,18 @@
 #
 # Basic tests for NMatrix.
 #
-require "./lib/nmatrix"
 
-describe NMatrix do
-  MATRIX43A_ARRAY = [14.0, 9.0, 3.0, 2.0, 11.0, 15.0, 0.0, 12.0, 17.0, 5.0, 2.0, 3.0]
-  MATRIX32A_ARRAY = [12.0, 25.0, 9.0, 10.0, 8.0, 5.0]
-
-  COMPLEX_MATRIX43A_ARRAY = MATRIX43A_ARRAY.zip(MATRIX43A_ARRAY.reverse).collect { |ary| Complex(ary[0], ary[1]) }
-  COMPLEX_MATRIX32A_ARRAY = MATRIX32A_ARRAY.zip(MATRIX32A_ARRAY.reverse).collect { |ary| Complex(ary[0], -ary[1]) }
+# Can we use require_relative here instead?
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
 
-  RATIONAL_MATRIX43A_ARRAY = MATRIX43A_ARRAY.collect { |x| x.to_r }
-  RATIONAL_MATRIX32A_ARRAY = MATRIX32A_ARRAY.collect { |x| x.to_r }
+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
+  end
 
-  it "allows stype casting of a rank 2 matrix between dense, sparse, and list (different dtypes)" do
+  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).
@@ -53,27 +51,27 @@ describe NMatrix do
   end
 
 
-  it "correctly compares two list matrices" do
+  it "compares two list matrices" do
     n = NMatrix.new(:list, [3,3,3], :int64)
     m = NMatrix.new(:list, [3,3,3], :int64)
-    n.should.eql? m
+    n.should == m
     n[0,0,0] = 5
-    n.should_not.eql? m
+    n.should_not == m
     n[0,0,1] = 52
     n[1,2,1] = -4
 
     m[0,0,0] = 5
     m[0,0,1] = 52
     m[1,2,1] = -4
-    n.should.eql? m
+    n.should == m
   end
 
-  it "correctly fills dense Ruby object matrix with nil" do
+  it "fills dense Ruby object matrix with nil" do
     n = NMatrix.new([4,3], :object)
     n[0,0].should == nil
   end
 
-  it "correctly fills dense with individual assignments" do
+  it "fills dense with individual assignments" do
     n = NMatrix.new([4,3], :float64)
     n[0,0] = 14.0
     n[0,1] = 9.0
@@ -102,7 +100,7 @@ describe NMatrix do
     n[3,2].should == 3.0
   end
 
-  it "correctly fills dense with a single mass assignment" do
+  it "fills dense with a single mass assignment" do
     n = NMatrix.new([4,3], [14.0, 9.0, 3.0, 2.0, 11.0, 15.0, 0.0, 12.0, 17.0, 5.0, 2.0, 3.0])
 
     n[0,0].should == 14.0
@@ -119,7 +117,7 @@ describe NMatrix do
     n[3,2].should == 3.0
   end
 
-  it "correctly fills dense with a single mass assignment, with dtype specified" do
+  it "fills dense with a single mass assignment, with dtype specified" do
     m = NMatrix.new([4,3], [14.0, 9.0, 3.0, 2.0, 11.0, 15.0, 0.0, 12.0, 17.0, 5.0, 2.0, 3.0], :float32)
     m[0,0].should == 14.0
     m[0,1].should == 9.0
@@ -135,56 +133,26 @@ describe NMatrix do
     m[3,2].should == 3.0
   end
 
-  [:float32, :float64].each do |dtype|
-    it "correctly exposes cblas_xgemm" do
-      #STDERR.puts "dtype=#{dtype.to_s}"
-      #STDERR.puts "1"
-      n = NMatrix.new([4,3], dtype)
-      n[0,0] = 14.0
-      n[0,1] = 9.0
-      n[0,2] = 3.0
-      n[1,0] = 2.0
-      n[1,1] = 11.0
-      n[1,2] = 15.0
-      n[2,0] = 0.0
-      n[2,1] = 12.0
-      n[2,2] = 17.0
-      n[3,0] = 5.0
-      n[3,1] = 2.0
-      n[3,2] = 3.0
-
-      m = NMatrix.new([3,2], dtype)
-
-      m[0,0] = 12.0
-      m[0,1] = 25.0
-      m[1,0] = 9.0
-      m[1,1] = 10.0
-      m[2,0] = 8.0
-      m[2,1] = 5.0
-
-      #c = NMatrix.new([4,2], dtype)
-      r = NMatrix.cblas_gemm(n, m) #, c)
-      #c.should equal(r) # check that both are same memory address
-
-      r[0,0].should == 273.0
-      r[0,1].should == 455.0
-      r[1,0].should == 243.0
-      r[1,1].should == 235.0
-      r[2,0].should == 244.0
-      r[2,1].should == 205.0
-      r[3,0].should == 102.0
-      r[3,1].should == 160.0
-    end
-  end
 
-  it "list correctly handles missing initialization value" do
+  it "list handles missing initialization value" do
     NMatrix.new(:list, 3, :int8)[0,0].should    == 0
     NMatrix.new(:list, 4, :float64)[0,0].should == 0.0
   end
 
+  it "should allow conversion of list storage to a Ruby Hash" do
+    n = NMatrix.new(:list, 3, 1, :int64)
+    n[0,1] = 50
+    h = n.to_h
+    h.size.should == 1
+    h[0].size.should == 1
+    h[0][1].should == 50
+    h[0][2].should == 1
+    h[1][0].should == 1
+  end
+
 
   ##TODO: Make this test better. It's not nearly exhaustive enough as is.
-  it "list correctly handles recursive removal" do
+  it "list handles recursive removal" do
     n = NMatrix.new(:list, [3,3,3], 0)
     n[0,0,0] = 2
     n[1,1,1] = 1
@@ -204,7 +172,7 @@ describe NMatrix do
   end
 
 
-  it "dense correctly handles missing initialization value" do
+  it "dense handles missing initialization value" do
     n = NMatrix.new(3, :int8)
     n.stype.should == :dense
     n.dtype.should == :int8
@@ -214,29 +182,21 @@ describe NMatrix do
     m.dtype.should == :float64
   end
 
-  it "dense correctly pretty_prints complex values" do
+  it "dense pretty_prints complex values" do
     n = NMatrix.new([4,3], COMPLEX_MATRIX43A_ARRAY, :complex128)
     n.pretty_print
   end
 
-  it "dense correctly handles elementwise addition" do
-    n = NMatrix.new(:dense, [2,2], [1,2,3,4], :int64)
-    m = NMatrix.new(:dense, [2,2], [-4,-1,0,66], :int64)
-    rcorrect = NMatrix.new(:dense, [2,2], [-3, 1, 3, 70], :int64)
-    r = n+m
-    r.should.eql? rcorrect
-  end
-
    # TODO: Get it working with ROBJ too
-  [:byte,:int8,:int16,:int32,:int64,:float32,:float64,:rational64,:rational128,:object].each do |left_dtype|
-    [:byte,:int8,:int16,:int32,:int64,:float32,:float64,:rational64,:rational128,:object].each do |right_dtype|
+  [:byte,:int8,:int16,:int32,:int64,:float32,:float64,:rational64,:rational128].each do |left_dtype|
+    [:byte,:int8,:int16,:int32,:int64,:float32,:float64,:rational64,:rational128].each do |right_dtype|
 
       # Won't work if they're both 1-byte, due to overflow.
       next if [:byte,:int8].include?(left_dtype) && [:byte,:int8].include?(right_dtype)
 
       # For now, don't bother testing int-int mult.
       #next if [:int8,:int16,:int32,:int64].include?(left_dtype) && [:int8,:int16,:int32,:int64].include?(right_dtype)
-      it "dense correctly handles #{left_dtype.to_s} dot #{right_dtype.to_s} matrix multiplication" do
+      it "dense handles #{left_dtype.to_s} dot #{right_dtype.to_s} matrix multiplication" do
         #STDERR.puts "dtype=#{dtype.to_s}"
         #STDERR.puts "2"
 
@@ -261,11 +221,11 @@ describe NMatrix do
 
         m.shape[0].should == 3
         m.shape[1].should == 2
-        m.rank.should == 2
+        m.dim.should == 2
 
         n.shape[0].should == 4
         n.shape[1].should == 3
-        n.rank.should == 2
+        n.dim.should == 2
 
         n.shape[1].should == m.shape[0]
 
@@ -291,7 +251,7 @@ describe NMatrix do
       # Won't work if they're both 1-byte, due to overflow.
       next if [:byte,:int8].include?(left_dtype) && [:byte,:int8].include?(right_dtype)
 
-      it "dense correctly handles #{left_dtype.to_s} dot #{right_dtype.to_s} vector multiplication" 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)
@@ -303,7 +263,7 @@ describe NMatrix do
 
         n.shape[0].should == 4
         n.shape[1].should == 3
-        n.rank.should == 2
+        n.dim.should == 2
 
         n.shape[1].should == m.shape[0]
 
@@ -322,7 +282,7 @@ describe NMatrix do
 
 
   [:dense, :list, :yale].each do |storage_type|
-    context "(storage: #{storage_type})" do
+    context storage_type do
       it "can be duplicated" do
         n = NMatrix.new(storage_type, [2,3], storage_type == :yale ? :float64 : 1.1)
         n.stype.should equal(storage_type)
@@ -333,7 +293,7 @@ describe NMatrix do
 
         m = n.dup
         m.shape.should == n.shape
-        m.rank.should == n.rank
+        m.dim.should == n.dim
         m.object_id.should_not == n.object_id
         m.stype.should equal(storage_type)
         m[0,0].should == n[0,0]
@@ -347,49 +307,93 @@ describe NMatrix do
         lambda { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[0,10] }.should raise_error(ArgumentError, "out of range")
       end
 
-      it "correctly sets and gets" do
+      it "sets and gets" do
         n = NMatrix.new(storage_type, 2, storage_type == :yale ? :int8 : 0)
-        (n[0,1] = 1).should == 1
+        n[0,1] = 1
         n[0,0].should == 0
         n[1,0].should == 0
         n[0,1].should == 1
         n[1,1].should == 0
       end
+
+      it "sets and gets references" do
+        n = NMatrix.new(storage_type, 2, storage_type == :yale ? :int8 : 0)
+        (n[0,1] = 1).should == 1
+        n[0,1].should == 1
+      end
+
     end
 
     # dense and list, not yale
     context "(storage: #{storage_type})" do
-      it "correctly gets default value" do
+      it "gets default value" do
         NMatrix.new(storage_type, 3, 0)[1,1].should   == 0
         NMatrix.new(storage_type, 3, 0.1)[1,1].should == 0.1
         NMatrix.new(storage_type, 3, 1)[1,1].should   == 1
       end
 
-      it "returns correct shape and rank" do
+      it "returns shape and dim" do
         NMatrix.new(storage_type, [3,2,8], 0).shape.should == [3,2,8]
-        NMatrix.new(storage_type, [3,2,8], 0).rank.should  == 3
+        NMatrix.new(storage_type, [3,2,8], 0).dim.should  == 3
       end
     end unless storage_type == :yale
   end
 
 
-  it "correctly handles dense construction" do
+  it "handles dense construction" do
     NMatrix.new(3,0)[1,1].should == 0
     lambda { NMatrix.new(3,:int8)[1,1] }.should_not raise_error
   end
 
-  it "correctly allows iteration of Ruby object matrices" do
+  it "allows iteration of Ruby object matrices" do
     n = NMatrix.new(:dense, [3,3], [1,2,3,4,5,6,7,8,9], :object)
     n.each do |x|
       puts x
     end
   end
 
-  it "correctly allows iteration of non-Ruby object matrices" do
+  it "allows iteration of non-Ruby object matrices" do
     n = NMatrix.new(:dense, [3,3], [1,2,3,4,5,6,7,8,9], :int64)
     n.each do |x|
       puts x
     end
   end
 
-end
+  it "calculates the complex conjugate in-place" do
+    n = NMatrix.new(:dense, 3, [1,2,3,4,5,6,7,8,9], :complex128)
+    n.complex_conjugate!
+    # FIXME: Actually test that values are correct.
+  end
+
+  it "converts from list to yale properly" do
+    m = NMatrix.new(:list, 3, 0)
+    m[0,2] = 333 
+    m[2,2] = 777
+    n = m.cast(:yale, :int32)
+    puts n.capacity
+    n.extend NMatrix::YaleFunctions
+    puts n.yale_ija.inspect
+    puts n.yale_a.inspect
+    n[0,0].should == 0
+    n[0,1].should == 0
+    n[0,2].should == 333
+    n[1,0].should == 0
+    n[1,1].should == 0
+    n[1,2].should == 0
+    n[2,0].should == 0
+    n[2,1].should == 0
+    n[2,2].should == 777
+  end
+
+  it "should return an enumerator when each is called without a block" do
+    a = NMatrix.new(2, 1)
+    b = NMatrix.new(2, [-1,0,1,0])
+    enums = [a.each, b.each]
+
+    begin
+      atans = []
+      atans << Math.atan2(*enums.map(&:next)) while true
+    rescue StopIteration
+    end
+  end
+end

data/spec/nmatrix_yale_spec.rb

@@ -27,85 +27,96 @@
 require "./lib/nmatrix"
 
 describe NMatrix do
-  it "correctly compares two empty yale matrices" 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 yale matrices" do
     n = NMatrix.new(:yale, [4,4], :float64)
     m = NMatrix.new(:yale, [4,4], :float64)
-    n.should.eql? m
+    n.should == m
   end
 
-  it "correctly compares two yale matrices following basic assignments" do
+  it "compares two yale matrices following basic assignments" do
     n = NMatrix.new(:yale, [2,2], :float64)
     m = NMatrix.new(:yale, [2,2], :float64)
     m[0,0] = 1
     m[0,1] = 1
-    n.should_not.eql? m
+    n.should_not == m
     n[0,0] = 1
-    n.should_not.eql? m
+    n.should_not == m
     n[0,1] = 1
-    n.should.eql? m
+    n.should == m
   end
 
-  it "correctly compares two yale matrices following elementwise operations" do
+  it "compares two yale matrices following elementwise operations" do
     n = NMatrix.new(:yale, [2,2], :float64)
     n[0,1] = 1
     m = NMatrix.new(:yale, [2,2], :float64)
     m[0,1] = -1
     r = NMatrix.new(:yale, [2,2], :float64)
     r[0,1] = 0
-    (n+m).should.eql? r
+    (n+m).should == r
   end
 
-  it "correctly sets diagonal values in yale" do
+  it "sets diagonal values in yale" do
     n = NMatrix.new(:yale, [2,3], :float64)
+    n.extend(NMatrix::YaleFunctions)
     n[1,1] = 0.1
     n[0,0] = 0.2
-    n.__yale_d__.should == [0.2, 0.1]
+    n.yale_d.should == [0.2, 0.1]
   end
 
   it "does not resize yale until necessary" do
     n = NMatrix.new(:yale, [2,3], :float64)
-    n.__yale_size__.should == 3
+    n.extend(NMatrix::YaleFunctions)
+    n.yale_size.should == 3
     n.capacity.should == 5
     n[0,0] = 0.1
     n[0,1] = 0.2
     n[1,0] = 0.3
-    n.__yale_size__.should == 5
+    n.yale_size.should == 5
     n.capacity.should == 5
   end
 
 
-  it "correctly sets when not resizing (yale)" do
+  it "sets when not resizing (yale)" do
     n = NMatrix.new(:yale, [2,3], :float64)
+    n.extend(NMatrix::YaleFunctions)
     n[0,0] = 0.1
     n[0,1] = 0.2
     n[1,0] = 0.3
-    n.__yale_a__ == [0.1, 0.0, 0.0, 0.2, 0.3]
-    n.__yale_ija__ == [3,4,5,1,0]
+    n.yale_a == [0.1, 0.0, 0.0, 0.2, 0.3]
+    n.yale_ija == [3,4,5,1,0]
   end
 
-  it "correctly sets when resizing (yale)" do
+  it "sets when resizing (yale)" do
     n = NMatrix.new(:yale, [2,3], :float64)
+    n.extend(NMatrix::YaleFunctions)
     n[0,0] = 0.01
     n[1,1] = 0.1
     n[0,1] = 0.2
     n[1,0] = 0.3
     n[1,2] = 0.4
-    n.__yale_d__.should == [0.01, 0.1]
-    n.__yale_ia__.should == [3,4,6]
-    n.__yale_ja__.should == [1,0,2,nil]
-    n.__yale_lu__.should == [0.2, 0.3, 0.4, nil]
+    n.yale_d.should == [0.01, 0.1]
+    n.yale_ia.should == [3,4,6]
+    n.yale_ja.should == [1,0,2,nil]
+    n.yale_lu.should == [0.2, 0.3, 0.4, nil]
   end
 
-  it "correctly sets values within rows of yale" do
+  it "sets values within rows of yale" do
     n = NMatrix.new(:yale, [3,20], :float64)
+    n.extend(NMatrix::YaleFunctions)
     n[2,1]   = 1.0
     n[2,0]   = 1.5
     n[2,15]  = 2.0
-    n.__yale_lu__.should == [1.5, 1.0, 2.0]
-    n.__yale_ja__.should == [0, 1, 15]
+    n.yale_lu.should == [1.5, 1.0, 2.0]
+    n.yale_ja.should == [0, 1, 15]
   end
 
-  it "correctly gets values within rows of yale" do
+  it "gets values within rows of yale" do
     n = NMatrix.new(:yale, [3,20], :float64)
     n[2,1]   = 1.0
     n[2,0]   = 1.5
@@ -115,8 +126,9 @@ describe NMatrix do
     n[2,15].should == 2.0
   end
 
-  it "correctly sets values within large rows of yale" do
+  it "sets values within large rows of yale" do
     n = NMatrix.new(:yale, [10,300], :float64)
+    n.extend(NMatrix::YaleFunctions)
     n[5,1]   = 1.0
     n[5,0]   = 1.5
     n[5,15]  = 2.0
@@ -127,12 +139,13 @@ describe NMatrix do
     n[5,293] = 2.0
     n[5,299] = 7.0
     n[5,100] = 8.0
-    n.__yale_lu__.should == [1.5, 1.0, 2.0, 8.0, 5.0, 6.0, 3.0, 4.0, 2.0, 7.0]
-    n.__yale_ja__.should == [0,   1,   15,  100, 289, 290, 291, 292, 293, 299]
+    n.yale_lu.should == [1.5, 1.0, 2.0, 8.0, 5.0, 6.0, 3.0, 4.0, 2.0, 7.0]
+    n.yale_ja.should == [0,   1,   15,  100, 289, 290, 291, 292, 293, 299]
   end
 
-  it "correctly gets values within large rows of yale" do
+  it "gets values within large rows of yale" do
     n = NMatrix.new(:yale, [10,300], :float64)
+    n.extend(NMatrix::YaleFunctions)
     n[5,1]   = 1.0
     n[5,0]   = 1.5
     n[5,15]  = 2.0
@@ -144,13 +157,13 @@ describe NMatrix do
     n[5,299] = 7.0
     n[5,100] = 8.0
 
-    n.__yale_ja__.each_index do |idx|
-      j = n.__yale_ja__[idx]
-      n[5,j].should == n.__yale_lu__[idx]
+    n.yale_ja.each_index do |idx|
+      j = n.yale_ja[idx]
+      n[5,j].should == n.yale_lu[idx]
     end
   end
 
-  it "correctly dots two identical yale matrices" do
+  it "dots two identical yale matrices" do
     a = NMatrix.new(:yale, 4, :float64)
     a[0,1] = 4.0
     a[1,2] = 1.0
@@ -178,8 +191,9 @@ describe NMatrix do
     c[3,3].should == 2.0
   end
 
-  it "correctly dots two identical yale matrices where a positive and negative partial sum cancel on the diagonal" do
+  it "dots two identical yale matrices where a positive and negative partial sum cancel on the diagonal" do
     a = NMatrix.new(:yale, 4, :float64)
+
     a[0,0] = 1.0
     a[0,1] = 4.0
     a[1,2] = 2.0
@@ -207,12 +221,14 @@ describe NMatrix do
     #c[3,2].should == 8.0
     #c[3,3].should == 0.0 # this is the positive and negative partial sum cancel
 
-    c.__yale_ija__.reject { |i| i.nil? }.should == [5,8,9,9,11,1,2,3,3,1,2]
-    c.__yale_a__.reject { |i| i.nil? }.should == [1.0, -16.0, 0.0, 0.0, 0.0, 4.0, 8.0, -16.0, -16.0, 16.0, 8.0]
+    c.extend(NMatrix::YaleFunctions)
+
+    c.yale_ija.reject { |i| i.nil? }.should == [5,8,9,9,11,1,2,3,3,1,2]
+    c.yale_a.reject { |i| i.nil? }.should == [1.0, -16.0, 0.0, 0.0, 0.0, 4.0, 8.0, -16.0, -16.0, 16.0, 8.0]
 
   end
 
-  it "correctly transposes yale" do
+  it "transposes yale" do
     a = NMatrix.new(:yale, 4, :float64)
     a[0,0] = 1.0
     a[0,1] = 4.0

data/spec/nvector_spec.rb

@@ -28,7 +28,7 @@
 require "./lib/nmatrix"
 
 describe NVector do
-  it "correctly initializes" do
+  it "initializes" do
     v = NVector.new 5, :float64
     v.shape[0].should == 5
     v.shape[1].should == 1