nmatrix 0.0.3 → 0.0.4

data/lib/nmatrix/version.rb

@@ -1,3 +1,4 @@
+#--
 # = NMatrix
 #
 # A linear algebra library for scientific computation in Ruby.
@@ -8,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+# NMatrix is Copyright (c) 2013, Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -19,9 +20,12 @@
 # our Contributor Agreement:
 #
 # * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
-#
+#++
 
 class NMatrix
-  VERSION = '0.0.3'
+  # 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.4"
 end
 

data/nmatrix.gemspec

@@ -22,12 +22,14 @@ such as for driving a car or flying a space shuttle, you
 may wish to choose other software (for now).
 
 NMatrix requires a C compiler, and has been tested only
-with GCC 4.6.1. We are happy to accept contributions
+with GCC 4.6+. We are happy to accept contributions
 which improve the portability of this project.
 
 Also required is ATLAS. Most Linux distributions and Mac
 versions include ATLAS, but you may wish to compile it
-yourself.
+yourself. Rumor has it that the Ubuntu/Debian apt package
+for ATLAS WILL NOT WORK with NMatrix. Please install it
+manually if you are using apt.
 
 More explicit instructions for NMatrix and SciRuby should
 be available on the SciRuby website, sciruby.com, or
@@ -47,7 +49,7 @@ EOF
 
   gem.required_ruby_version = '>= 1.9.2'
 
-  #gem.add_dependency 'csquare', '~>0.0.2'
+  gem.add_dependency 'rdoc', '>=4.0.1'
 
   gem.add_development_dependency 'rake', '~>0.9'
   gem.add_development_dependency 'bundler'

data/scripts/mac-brew-gcc.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-VERSION="4.7.1"
+VERSION="4.7.2"
 PREFIX="/usr/gcc-${VERSION}"
 LANGUAGES="c,c++,fortran"
 MAKE="make -j 4"

data/spec/blas_spec.rb

@@ -31,7 +31,10 @@ require File.join(File.dirname(__FILE__), "spec_helper.rb")
 describe NMatrix::BLAS do
   [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do
-      it "exposes cblas trsm" do
+      # This is not the same as "exposes cblas trsm", which would be for a version defined in blas.rb (which
+      # would greatly simplify the calling of cblas_trsm in terms of arguments, and which would be accessible
+      # as NMatrix::BLAS::trsm)
+      it "exposes unfriendly cblas_trsm" do
         a     = NMatrix.new(:dense, 3, [4,-1.quo(2), -3.quo(4), -2, 2, -1.quo(4), -4, -2, -1.quo(2)], dtype)
         b     = NVector.new(3, [-1, 17, -9], dtype)
         NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nonunit, 1, 3, 1.0, a, 3, b, 3)
@@ -64,7 +67,7 @@ describe NMatrix::BLAS do
 
   [:float32, :float64].each do |dtype|
     context dtype do
-      it "exposes cblas rot" 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)
@@ -82,6 +85,24 @@ describe NMatrix::BLAS do
         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)
+        y = NVector.new(5, [-5,-4,-3,-2,-1], dtype)
+        x, y = NMatrix::BLAS::rot(x, y, 0.5, Math.sqrt(3)/2, -1)
+
+        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
+
       # 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)
@@ -94,4 +115,61 @@ describe NMatrix::BLAS do
 
     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
+
+
+      it "exposes gemv" do
+        #a = NMatrix.random(3)
+        #x = NVector.random(3)
+        a = 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], :float64)
+        x = NVector.new(3, [2.0, 1.0, 0.0], :float64)
+
+        NMatrix::BLAS.gemv(a, x)
+      end
+
+    end
+  end
 end

data/spec/math_spec.rb

@@ -56,39 +56,49 @@ describe "math" do
     end
   end
 
-  [:float32, :float64, :complex64, :complex128].each do |dtype|
-    context dtype do
+  # TODO: Get it working with ROBJ too
+  [: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)
 
-      # Note: this exposes gemm, not cblas_gemm (which is the unfriendly CBLAS no-error-checking version)
-      it "exposes gemm" do
+      # 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 handles #{left_dtype.to_s} dot #{right_dtype.to_s} matrix multiplication" 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
+        #STDERR.puts "2"
+
+        nary = if left_dtype.to_s =~ /complex/
+                 COMPLEX_MATRIX43A_ARRAY
+               elsif left_dtype.to_s =~ /rational/
+                 RATIONAL_MATRIX43A_ARRAY
+               else
+                 MATRIX43A_ARRAY
+               end
+
+        mary = if right_dtype.to_s =~ /complex/
+                 COMPLEX_MATRIX32A_ARRAY
+               elsif right_dtype.to_s =~ /rational/
+                 RATIONAL_MATRIX32A_ARRAY
+               else
+                 MATRIX32A_ARRAY
+               end
+
+        n = NMatrix.new([4,3], nary, left_dtype)
+        m = NMatrix.new([3,2], mary, right_dtype)
+
+        m.shape[0].should == 3
+        m.shape[1].should == 2
+        m.dim.should == 2
+
+        n.shape[0].should == 4
+        n.shape[1].should == 3
+        n.dim.should == 2
+
+        n.shape[1].should == m.shape[0]
+
+        r = n.dot m
 
         r[0,0].should == 273.0
         r[0,1].should == 455.0
@@ -98,8 +108,44 @@ describe "math" do
         r[2,1].should == 205.0
         r[3,0].should == 102.0
         r[3,1].should == 160.0
+
+        #r.dtype.should == :float64 unless left_dtype == :float32 && right_dtype == :float32
       end
+    end
+  end
 
+  [: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)
+
+      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)
+
+        m = NVector.new(3, [2.0, 1.0, 0.0], right_dtype)
+
+        m.shape[0].should == 3
+        m.shape[1].should == 1
+
+        n.shape[0].should == 4
+        n.shape[1].should == 3
+        n.dim.should == 2
+
+        n.shape[1].should == m.shape[0]
+
+        r = n.dot m
+        # r.class.should == NVector
+
+        r[0,0].should == 4
+        r[1,0].should == 13
+        r[2,0].should == 22
+        r[3,0].should == 31
+
+        #r.dtype.should == :float64 unless left_dtype == :float32 && right_dtype == :float32
+      end
     end
   end
-end
+end

data/spec/nmatrix_list_spec.rb

@@ -28,68 +28,68 @@ require "./lib/nmatrix"
 
 describe NMatrix do
   context :list do
-  it "should compare with ==" do
-    n = NMatrix.new(:list, [3,3,3], :int64)
-    m = NMatrix.new(:list, [3,3,3], :int64)
-    n.should == m
-    n[0,0,0] = 5
-    n.should_not == m
-    n[0,0,1] = 52
-    n[1,2,1] = -4
+    it "should compare with ==" do
+      n = NMatrix.new(:list, [3,3,3], :int64)
+      m = NMatrix.new(:list, [3,3,3], :int64)
+      n.should == m
+      n[0,0,0] = 5
+      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 == m
-  end
+      m[0,0,0] = 5
+      m[0,0,1] = 52
+      m[1,2,1] = -4
+      n.should == m
+    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
-  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
+    end
 
-  it "should allow conversion 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
+    it "should allow conversion 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 "should handle recursive removal" do
-    n = NMatrix.new(:list, [3,3,3], 0)
-    n[0,0,0] = 2
-    n[1,1,1] = 1
-    n[1,0,0] = 3
-    n[0,0,1] = 4
+    ##TODO: Make this test better. It's not nearly exhaustive enough as is.
+    it "should handle recursive removal" do
+      n = NMatrix.new(:list, [3,3,3], 0)
+      n[0,0,0] = 2
+      n[1,1,1] = 1
+      n[1,0,0] = 3
+      n[0,0,1] = 4
 
-    n[0,0,0].should == 2
-    n[1,1,1].should == 1
-    n[1,0,0].should == 3
-    n[0,0,1].should == 4
+      n[0,0,0].should == 2
+      n[1,1,1].should == 1
+      n[1,0,0].should == 3
+      n[0,0,1].should == 4
 
-    n[1,1,1] = 0
-    n[0,0,0].should == 2
-    n[1,1,1].should == 0
-    n[1,0,0].should == 3
-    n[0,0,1].should == 4
-  end
+      n[1,1,1] = 0
+      n[0,0,0].should == 2
+      n[1,1,1].should == 0
+      n[1,0,0].should == 3
+      n[0,0,1].should == 4
+    end
 
-  it "should correctly insert a value between the middle and last entries of a three-element list" do
-    n = NMatrix.new(:list, 5940, 0, :float64)
-    n[0,0] = -7.0710685196786e-01
-    n[330,0] = 7.0710685196786e-01
-    n[1,0] = -7.0710685196786e-01
-    n[2,0] = -7.0710685196786e-01
-    n[0,0].should_not == 0
-    n[330,0].should_not == 0
-    n[2,0].should_not == 0
-    n[1,0].should_not == 0
-  end
+    it "should correctly insert a value between the middle and last entries of a three-element list" do
+      n = NMatrix.new(:list, 5940, 0, :float64)
+      n[0,0] = -7.0710685196786e-01
+      n[330,0] = 7.0710685196786e-01
+      n[1,0] = -7.0710685196786e-01
+      n[2,0] = -7.0710685196786e-01
+      n[0,0].should_not == 0
+      n[330,0].should_not == 0
+      n[2,0].should_not == 0
+      n[1,0].should_not == 0
+    end
   end
 end

data/spec/nmatrix_spec.rb

@@ -42,14 +42,14 @@ describe NMatrix 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).
-        cast(:list, :int32).
-        cast(:dense, :int16).
-        cast(:list, :int32).
-        cast(:yale, :int64) #.
-        #cast(:list, :int32).
-        #cast(:dense, :int16)
+      cast(:yale, :int32).
+      cast(:dense, :float64).
+      cast(:list, :int32).
+      cast(:dense, :int16).
+      cast(:list, :int32).
+      cast(:yale, :int64) #.
+    #cast(:list, :int32).
+    #cast(:dense, :int16)
     #m.should.equal?(original)
     # For some reason this causes some weird garbage collector problems when we uncomment these. The above lines won't
     # work at all in IRB, but work fine when run in a regular Ruby session.
@@ -139,99 +139,6 @@ describe NMatrix do
     n.pretty_print
   end
 
-   # TODO: Get it working with ROBJ too
-  [: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 handles #{left_dtype.to_s} dot #{right_dtype.to_s} matrix multiplication" do
-        #STDERR.puts "dtype=#{dtype.to_s}"
-        #STDERR.puts "2"
-
-        nary = if left_dtype.to_s =~ /complex/
-                 COMPLEX_MATRIX43A_ARRAY
-               elsif left_dtype.to_s =~ /rational/
-                 RATIONAL_MATRIX43A_ARRAY
-               else
-                 MATRIX43A_ARRAY
-               end
-
-        mary = if right_dtype.to_s =~ /complex/
-                 COMPLEX_MATRIX32A_ARRAY
-               elsif right_dtype.to_s =~ /rational/
-                 RATIONAL_MATRIX32A_ARRAY
-               else
-                 MATRIX32A_ARRAY
-               end
-
-        n = NMatrix.new([4,3], nary, left_dtype)
-        m = NMatrix.new([3,2], mary, right_dtype)
-
-        m.shape[0].should == 3
-        m.shape[1].should == 2
-        m.dim.should == 2
-
-        n.shape[0].should == 4
-        n.shape[1].should == 3
-        n.dim.should == 2
-
-        n.shape[1].should == m.shape[0]
-
-        r = n.dot m
-
-        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
-
-        #r.dtype.should == :float64 unless left_dtype == :float32 && right_dtype == :float32
-      end
-    end
-  end
-
-  [: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)
-
-      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)
-
-        m = NVector.new(3, [2.0, 1.0, 0.0], right_dtype)
-
-        m.shape[0].should == 3
-        m.shape[1].should == 1
-
-        n.shape[0].should == 4
-        n.shape[1].should == 3
-        n.dim.should == 2
-
-        n.shape[1].should == m.shape[0]
-
-        r = n.dot m
-        # r.class.should == NVector
-
-        r[0,0].should == 4
-        r[1,0].should == 13
-        r[2,0].should == 22
-        r[3,0].should == 31
-
-        #r.dtype.should == :float64 unless left_dtype == :float32 && right_dtype == :float32
-      end
-    end
-  end
-
 
   [:dense, :list, :yale].each do |storage_type|
     context storage_type do
@@ -274,6 +181,51 @@ describe NMatrix do
         n[0,1].should == 1
       end
 
+      # Tests Ruby object versus any C dtype (in this case we use :int64)
+      [:object, :int64].each do |dtype|
+        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.each do |x|
+              puts x
+            end
+          end
+
+          it "allows storage-based iteration of matrices" do
+            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
+            n[2,2] = 3
+            n[2,1] = 4
+
+            values = []
+            is = []
+            js = []
+            n.each_stored_with_indices do |v,i,j|
+              values << v
+              is << i
+              js << j
+            end
+
+            if storage_type == :yale
+              values.should == [1,0,3,2,4]
+              is.should     == [0,1,2,0,2]
+              js.should     == [0,1,2,1,1]
+            elsif storage_type == :list
+              values.should == [1,2,4,3]
+              is.should     == [0,0,2,2]
+              js.should     == [0,1,1,2]
+            elsif storage_type == :dense
+              values.should == [1,2,0,0,0,0,0,4,3]
+              is.should     == [0,0,0,1,1,1,2,2,2]
+              js.should     == [0,1,2,0,1,2,0,1,2]
+            end
+          end
+        end
+      end
+
     end
 
     # dense and list, not yale
@@ -288,7 +240,7 @@ describe NMatrix do
         NMatrix.new(storage_type, [3,2,8], 0).shape.should == [3,2,8]
         NMatrix.new(storage_type, [3,2,8], 0).dim.should  == 3
       end
-      
+
       it "returns number of rows and columns" do
         NMatrix.new(storage_type, [7, 4], 3).rows.should == 7
         NMatrix.new(storage_type, [7, 4], 3).cols.should == 4
@@ -302,20 +254,6 @@ describe NMatrix do
     lambda { NMatrix.new(3,:int8)[1,1] }.should_not raise_error
   end
 
-  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 "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
-
   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!
@@ -324,7 +262,7 @@ describe NMatrix do
 
   it "converts from list to yale properly" do
     m = NMatrix.new(:list, 3, 0)
-    m[0,2] = 333 
+    m[0,2] = 333
     m[2,2] = 777
     n = m.cast(:yale, :int32)
     puts n.capacity
@@ -353,4 +291,9 @@ describe NMatrix do
     rescue StopIteration
     end
   end
+
+  it "should iterate through element 256 without a segfault" do
+    t = NVector.random(256)
+    t.each { |x| x + 0 }
+  end
 end