nmatrix 0.0.9 → 0.1.0.rc1

data/spec/math_spec.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -26,10 +26,101 @@
 # versions of unfriendly BLAS and LAPACK functions.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 
 describe "math" do
+  #after :each do
+  #  GC.start
+  #end
+
+  context "elementwise math functions" do
+
+    [:dense,:list,:yale].each do |stype|
+      context stype do
+
+        [:int64,:float64,:rational128].each do |dtype|
+          context dtype do
+            before :each do
+              @size = [2,2]
+              @m = NMatrix.seq(@size, dtype: dtype, stype: stype)+1
+              @a = @m.to_a.flatten
+            end
+
+            NMatrix::NMMath::METHODS_ARITY_1.each do |meth|
+              #skip inverse regular trig functions
+              next if meth.to_s.start_with?('a') and (not meth.to_s.end_with?('h')) \
+                and NMatrix::NMMath::METHODS_ARITY_1.include?(
+                  meth.to_s[1...meth.to_s.length].to_sym)
+              next if meth == :atanh
+
+              it "should correctly apply elementwise #{meth}" do
+
+                @m.send(meth).should eq N.new(@size, @a.map{ |e| Math.send(meth, e) },
+                                                 dtype: :float64, stype: stype)
+              end
+            end
+
+            NMatrix::NMMath::METHODS_ARITY_2.each do |meth|
+              next if meth == :atan2
+              it "should correctly apply elementwise #{meth}" do
+                @m.send(meth, @m).should eq N.new(@size, @a.map{ |e|
+                                                     Math.send(meth, e, e) },
+                                                     dtype: :float64, 
+                                                     stype: stype)
+              end
+
+              it "should correctly apply elementwise #{meth} with a scalar first arg" do
+                Math.send(meth, 1, @m).should eq N.new(@size, @a.map { |e| Math.send(meth, 1, e) }, dtype: :float64, stype: stype)
+              end
+
+              it "should correctly apply elementwise #{meth} with a scalar second arg" do
+                @m.send(meth, 1).should eq N.new(@size, @a.map { |e| Math.send(meth, e, 1) }, dtype: :float64, stype: stype)
+              end
+            end
+
+            it "should correctly apply elementwise natural log" do
+              @m.log.should eq N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
+                                        dtype: :float64, stype: stype)
+            end
+
+            it "should correctly apply elementwise log with arbitrary base" do
+              @m.log(3).should eq N.new(@size, [0, Math.log(2,3), 1, Math.log(4,3)],
+                                           dtype: :float64, stype: stype)
+            end
+
+            context "inverse trig functions" do
+              before :each do
+                @m = NMatrix.seq(@size, dtype: dtype, stype: stype)/4
+                @a = @m.to_a.flatten
+              end
+              [:asin, :acos, :atan, :atanh].each do |atf|
+
+                it "should correctly apply elementwise #{atf}" do
+                  @m.send(atf).should eq N.new(@size, 
+                                               @a.map{ |e| Math.send(atf, e) },
+                                               dtype: :float64, stype: stype)
+                end
+              end
+
+              it "should correctly apply elementtwise atan2" do
+                @m.atan2(@m*0+1).should eq N.new(@size, 
+                  @a.map { |e| Math.send(:atan2, e, 1) }, dtype: :float64, stype: stype)
+              end
+
+              it "should correctly apply elementwise atan2 with a scalar first arg" do
+                Math.atan2(1, @m).should eq N.new(@size, @a.map { |e| Math.send(:atan2, 1, e) }, dtype: :float64, stype: stype)
+              end
+
+              it "should correctly apply elementwise atan2 with a scalar second arg" do
+                  @m.atan2(1).should eq N.new(@size, @a.map { |e| Math.send(:atan2, e, 1) }, dtype: :float64, stype: stype)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
 
   [:float32, :float64, :complex64, :complex128, :rational32, :rational64, :rational128].each do |dtype|
     context dtype do

data/spec/nmatrix_yale_spec.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -27,6 +27,10 @@
 require "./lib/nmatrix"
 
 describe NMatrix do
+  #after :each do
+  #  GC.start
+  #end
+
   context :yale do
 
     it "compares two empty matrices" do
@@ -106,8 +110,8 @@ describe NMatrix do
       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.should == [0.1, 0.0, 0.0, 0.2, 0.3]
+      n.yale_ija.should == [3,4,5,1,0]
     end
 
     it "sets when resizing" do
@@ -267,28 +271,19 @@ describe NMatrix do
       mn[0,0].should == 541
     end
 
-    it "transposes" do
-      a = NMatrix.new(4, 0.0, stype: :yale)
-      a[0,0] = 1.0
-      a[0,1] = 4.0
-      a[1,2] = 2.0
-      a[1,3] = -4.0
-      a[3,1] = 5.0
-      a[3,3] = 6.0
-      b = a.transpose
-
-      b[0,0].should == 1.0
-      b[1,0].should == 4.0
-      b[2,0].should == 0.0
-      b[3,0].should == 0.0
-      b[0,1].should == 0.0
-      b[1,1].should == 0.0
-      b[2,1].should == 2.0
-      b[3,1].should == -4.0
-      b[0,3].should == 0.0
-      b[1,3].should == 5.0
-      b[2,3].should == 0.0
-      b[3,3].should == 6.0
+    it "calculates the row key intersections of two matrices" do
+      a = NMatrix.new([3,9], [0,1], stype: :yale, dtype: :byte, default: 0)
+      b = NMatrix.new([3,9], [0,0,1,0,1], stype: :yale, dtype: :byte, default: 0)
+      a.extend NMatrix::YaleFunctions
+      b.extend NMatrix::YaleFunctions
+
+      (0...3).each do |ai|
+        (0...3).each do |bi|
+          STDERR.puts (a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).inspect
+          (a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).should == a.yale_row_keys_intersection(ai, b, bi)
+        end
+      end
+
     end
   end
 end

data/spec/rspec_monkeys.rb

@@ -1,3 +1,30 @@
+# = 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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+#
+# == rspec_monkeys.rb
+#
+# A set of monkey patches for RSpec allowing checks of NMatrix types
+#
+
 module RSpec::Matchers::BuiltIn
   class BeWithin
 

data/spec/rspec_spec.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #

data/spec/shortcuts_spec.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -30,6 +30,9 @@ require File.join(File.dirname(__FILE__), "spec_helper.rb")
 require 'pry'
 
 describe NMatrix do
+  #after :each do
+  #  GC.start
+  #end
 
   it "zeros() creates a matrix of zeros" do
     m = NMatrix.zeros(3)
@@ -175,13 +178,8 @@ describe NMatrix do
 
   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
@@ -190,11 +188,8 @@ describe NMatrix do
     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
 

data/spec/slice_set_spec.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -30,6 +30,10 @@ require File.dirname(__FILE__) + "/spec_helper.rb"
 describe "Set slice operation" do
   include RSpec::Longrun::DSL
 
+  #after :each do
+  #  GC.start
+  #end
+
   [:dense, :yale, :list].each do |stype|
     context "for #{stype}" do
       before :each do

data/spec/spec_helper.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -25,6 +25,7 @@
 # Common data and helper functions for testing.
 
 require "rspec/longrun"
+#require "narray/narray"
 
 require "./lib/nmatrix"
 require "./lib/nmatrix/rspec"

data/spec/stat_spec.rb

@@ -8,8 +8,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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -31,162 +31,178 @@ require 'pry'
 
 describe "Statistical functions" do
   context "mapping and reduction related functions" do
-
-    before :each do
-      @nm_1d = NMatrix[5.0,0.0,1.0,2.0,3.0]
-      @nm_2d = NMatrix[[0.0,1.0],[2.0,3.0]]
-    end
-
-    it "behaves like Enumerable#reduce with no argument to reduce" do
-      @nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f.should eq 11
-      @nm_2d.reduce_along_dim(1) { |acc, el| acc + el }.should eq NMatrix[[1, 5]]
-    end
-
-    it "should calculate the mean along the specified dimension" do
-      @nm_1d.mean.should eq NMatrix[2.2]
-      @nm_2d.mean.should eq NMatrix[[1.0,2.0]]
-    end
-
-    it "should calculate the minimum along the specified dimension" do
-      @nm_1d.min.should eq 0.0
-      @nm_2d.min.should eq NMatrix[[0.0, 1.0]]
-      @nm_2d.min(1).should eq NMatrix[[0.0], [2.0]]
-    end
-
-    it "should calculate the maximum along the specified dimension" do
-      @nm_1d.max.should eq 5.0
-      @nm_2d.max.should eq NMatrix[[2.0, 3.0]]
-    end
-
-    it "should calculate the variance along the specified dimension" do
-      @nm_1d.variance.should eq NMatrix[3.7]
-      @nm_2d.variance(1).should eq NMatrix[[0.5], [0.5]]
-    end
-
-    it "should calculate the sum along the specified dimension" do
-      @nm_1d.sum.should eq NMatrix[11]
-      @nm_2d.sum.should eq NMatrix[[2], [4]]
-    end
-
-    it "should calculate the standard deviation along the specified dimension" do
-      @nm_1d.std.should eq NMatrix[Math.sqrt(3.7)]
-      @nm_2d.std(1).should eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)]]
-    end
-
-    it "should raise an ArgumentError when any invalid dimension is provided" do
-      expect { @nm_1d.mean(3) }.to raise_exception(RangeError)
-    end
-
-    it "should convert to float if it contains only a single element" do
-      NMatrix[4.0].to_f.should eq 4.0
-      NMatrix[[[[4.0]]]].to_f.should eq 4.0
-    end
-
-    it "should raise an index error if it contains more than a single element" do
-      expect { @nm_1d.to_f }.to raise_error(IndexError)
-    end
-
-    it "should map a block to all elements" do
-      @nm_1d.map { |e| e ** 2 }.should eq NMatrix[25.0,0.0,1.0,4.0,9.0]
-      @nm_2d.map { |e| e ** 2 }.should eq NMatrix[[0.0,1.0],[4.0,9.0]]
-    end
-
-    it "should map! a block to all elements in place" do
-      fct = Proc.new { |e| e ** 2 }
-      expected1 = @nm_1d.map &fct
-      expected2 = @nm_2d.map &fct
-      @nm_1d.map! &fct
-      @nm_1d.should eq expected1
-      @nm_2d.map! &fct
-      @nm_2d.should eq expected2
-    end
-
-    it "should return an enumerator for map without a block" do
-      @nm_1d.map.should be_a Enumerator
-    end
-
-    it "should return an enumerator for reduce without a block" do
-      @nm_1d.reduce_along_dim(0).should be_a Enumerator
-    end
-
-    it "should return an enumerator for each_along_dim without a block" do
-      @nm_1d.each_along_dim(0).should be_a Enumerator
-    end
-
-    it "should iterate correctly for map without a block" do
-      en = @nm_1d.map
-      en.each { |e| e**2 }.should eq @nm_1d.map { |e| e**2 }
-      en = @nm_2d.map
-      en.each { |e| e**2 }.should eq @nm_2d.map { |e| e**2 }
-    end
-
-    it "should iterate correctly for reduce without a block" do
-      en = @nm_1d.reduce_along_dim(0, 1.0)
-      en.each { |a, e| a+e }.to_f.should eq 12
-      en = @nm_2d.reduce_along_dim(1, 1.0)
-      en.each { |a, e| a+e }.should eq NMatrix[[2.0],[6.0]]
-    end
-
-    it "should iterate correctly for each_along_dim without a block" do
-      res = NMatrix.zeros_like(@nm_1d[0...1])
-      en = @nm_1d.each_along_dim(0)
-      en.each { |e| res += e }
-      res.to_f.should eq 11
-
-      res = NMatrix.zeros_like (@nm_2d[0...2, 0])
-      en = @nm_2d.each_along_dim(1)
-      en.each { |e| res += e }
-      res.should eq NMatrix[[1.0], [5.0]]
-    end
-
-    it "should yield matrices of matching dtype for each_along_dim" do
-      m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128)
-      m.each_along_dim(1) do |sub_m|
-        sub_m.dtype.should eq :complex128
-      end
-    end
-
-    it "should reduce to a matrix of matching dtype for reduce_along_dim" do
-      m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128)
-      m.reduce_along_dim(1) do |acc, sub_m|
-        sub_m.dtype.should eq :complex128
-        acc
-      end
-
-      m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128)
-      m.reduce_along_dim(1, 0.0) do |acc, sub_m|
-        sub_m.dtype.should eq :complex128
-        acc
-      end
-    end
-
-    it "should allow overriding the dtype for reduce_along_dim" do
-      m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128]
-      m.reduce_along_dim(1, 0.0, :float64) do |acc, sub_m|
-        acc.dtype.should eq :float64
-        acc
-      end
-
-      m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128]
-      m.reduce_along_dim(1, nil, :float64) do |acc, sub_m|
-        acc.dtype.should eq :float64
-        acc
+    [:dense, :yale, :list].each do |stype|
+      context "on #{stype} matrices" do 
+        before :each do
+          @nm_1d = NMatrix.new([5], [5.0,0.0,1.0,2.0,3.0], stype: stype) unless stype == :yale
+          @nm_2d = NMatrix.new([2,2], [0.0, 1.0, 2.0, 3.0], stype: stype)
+        end
+
+        it "behaves like Enumerable#reduce with no argument to reduce" do
+          @nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f.should eq 11 unless stype == :yale
+          @nm_2d.reduce_along_dim(1) { |acc, el| acc + el }.should eq NMatrix.new([2,1], [1.0, 5.0], stype: stype)
+        end
+
+        it "should calculate the mean along the specified dimension" do
+          unless stype == :yale then
+            puts @nm_1d.mean
+            @nm_1d.mean.should eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
+          end
+          @nm_2d.mean.should eq NMatrix[[1.0,2.0], stype: stype]
+          @nm_2d.mean(1).should eq NMatrix[[0.5], [2.5], stype: stype]
+        end
+
+        it "should calculate the minimum along the specified dimension" do
+          @nm_1d.min.should eq 0.0 unless stype == :yale
+          @nm_2d.min.should eq NMatrix[[0.0, 1.0], stype: stype]
+          @nm_2d.min(1).should eq NMatrix[[0.0], [2.0], stype: stype]
+        end
+
+        it "should calculate the maximum along the specified dimension" do
+          @nm_1d.max.should eq 5.0  unless stype == :yale
+          @nm_2d.max.should eq NMatrix[[2.0, 3.0], stype: stype]
+        end
+
+        it "should calculate the variance along the specified dimension" do
+          @nm_1d.variance.should eq NMatrix[3.7, stype: stype] unless stype == :yale
+          @nm_2d.variance(1).should eq NMatrix[[0.5], [0.5], stype: stype]
+        end
+
+        it "should calculate the sum along the specified dimension" do
+          @nm_1d.sum.should eq NMatrix[11.0, stype: stype] unless stype == :yale
+          @nm_2d.sum.should eq NMatrix[[2.0, 4.0], stype: stype]
+        end
+
+        it "should calculate the standard deviation along the specified dimension" do
+          @nm_1d.std.should eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
+          @nm_2d.std(1).should eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)], stype: stype]
+        end
+
+        it "should raise an ArgumentError when any invalid dimension is provided" do
+          expect { @nm_1d.mean(3) }.to raise_exception(RangeError) unless stype == :yale
+          expect { @nm_2d.mean(3) }.to raise_exception(RangeError)
+        end
+
+        it "should convert to float if it contains only a single element" do
+          NMatrix[4.0, stype: stype].to_f.should eq 4.0  unless stype == :yale
+          NMatrix[[[[4.0]]], stype: stype].to_f.should eq 4.0  unless stype == :yale
+          NMatrix[[4.0], stype: stype].to_f.should eq 4.0
+        end
+
+        it "should raise an index error if it contains more than a single element" do
+          expect { @nm_1d.to_f }.to raise_error(IndexError)  unless stype == :yale
+          expect { @nm_2d.to_f }.to raise_error(IndexError)
+        end
+
+        it "should map a block to all elements" do
+          #binding.pry if stype == :list
+          @nm_1d.map { |e| e ** 2 }.should eq NMatrix[25.0,0.0,1.0,4.0,9.0, stype: stype] unless stype == :yale
+          @nm_2d.map { |e| e ** 2 }.should eq NMatrix[[0.0,1.0],[4.0,9.0], stype: stype]
+        end
+
+        it "should map! a block to all elements in place" do
+          fct = Proc.new { |e| e ** 2 }
+          unless stype == :yale then
+            expected1 = @nm_1d.map &fct
+            @nm_1d.map! &fct
+            @nm_1d.should eq expected1
+          end
+          expected2 = @nm_2d.map &fct
+          @nm_2d.map! &fct
+          @nm_2d.should eq expected2
+        end
+
+        it "should return an enumerator for map without a block" do
+          @nm_2d.map.should be_a Enumerator
+        end
+
+        it "should return an enumerator for reduce without a block" do
+          @nm_2d.reduce_along_dim(0).should be_a Enumerator
+        end
+
+        it "should return an enumerator for each_along_dim without a block" do
+          @nm_2d.each_along_dim(0).should be_a Enumerator
+        end
+
+        it "should iterate correctly for map without a block" do
+          en = @nm_1d.map unless stype == :yale
+          en.each { |e| e**2 }.should eq @nm_1d.map { |e| e**2 } unless stype == :yale
+          en = @nm_2d.map
+          en.each { |e| e**2 }.should eq @nm_2d.map { |e| e**2 }
+        end
+
+        it "should iterate correctly for reduce without a block" do
+          unless stype == :yale then
+            en = @nm_1d.reduce_along_dim(0, 1.0)
+            en.each { |a, e| a+e }.to_f.should eq 12
+          end
+          en = @nm_2d.reduce_along_dim(1, 1.0)
+          en.each { |a, e| a+e }.should eq NMatrix[[2.0],[6.0], stype: stype]
+        end
+
+        it "should iterate correctly for each_along_dim without a block" do
+          unless stype == :yale then
+            res = NMatrix.zeros_like(@nm_1d[0...1])
+            en = @nm_1d.each_along_dim(0)
+            en.each { |e| res += e }
+            res.to_f.should eq 11
+          end
+          res = NMatrix.zeros_like (@nm_2d[0...2, 0])
+          en = @nm_2d.each_along_dim(1)
+          en.each { |e| res += e }
+          res.should eq NMatrix[[1.0], [5.0], stype: stype]
+        end
+
+        it "should yield matrices of matching dtype for each_along_dim" do
+          m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
+          m.each_along_dim(1) do |sub_m|
+            sub_m.dtype.should eq :complex128
+          end
+        end
+
+        it "should reduce to a matrix of matching dtype for reduce_along_dim" do
+          m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
+          m.reduce_along_dim(1) do |acc, sub_m|
+            sub_m.dtype.should eq :complex128
+            acc
+          end
+
+          m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
+          m.reduce_along_dim(1, 0.0) do |acc, sub_m|
+            sub_m.dtype.should eq :complex128
+            acc
+          end
+        end
+
+        it "should allow overriding the dtype for reduce_along_dim" do
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128]
+          m.reduce_along_dim(1, 0.0, :float64) do |acc, sub_m|
+            acc.dtype.should eq :float64
+            acc
+          end
+
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128, stype: stype]
+          m.reduce_along_dim(1, nil, :float64) do |acc, sub_m|
+            acc.dtype.should eq :float64
+            acc
+          end
+        end
+
+        it "should convert integer dtypes to float when calculating mean" do
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
+          m.mean(0).dtype.should eq :float64
+        end
+
+        it "should convert integer dtypes to float when calculating variance" do
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
+          m.variance(0).dtype.should eq :float64
+        end
+
+        it "should convert integer dtypes to float when calculating standard deviation" do
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
+          m.std(0).dtype.should eq :float64
+        end
       end
     end
-
-    it "should convert integer dtypes to float when calculating mean" do
-      m = NMatrix[[1,2,3], [3,4,5], dtype: :int32]
-      m.mean(0).dtype.should eq :float64
-    end
-
-    it "should convert integer dtypes to float when calculating variance" do
-      m = NMatrix[[1,2,3], [3,4,5], dtype: :int32]
-      m.variance(0).dtype.should eq :float64
-    end
-
-    it "should convert integer dtypes to float when calculating standard deviation" do
-      m = NMatrix[[1,2,3], [3,4,5], dtype: :int32]
-      m.std(0).dtype.should eq :float64
-    end
   end
-end
+end