pnmatrix 1.2.4

data/spec/blas_spec.rb

@@ -0,0 +1,215 @@
+# = 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
+#
+# == blas_spec.rb
+#
+# Tests for properly exposed BLAS functions.
+#
+
+require 'spec_helper'
+
+describe NMatrix::BLAS do
+  [:byte, :int8, :int16, :int32, :int64,
+   :float32, :float64, :complex64, :complex128,
+   :object
+  ].each do |dtype|
+    context dtype do
+      it "exposes cblas_scal" do
+        x = NMatrix.new([3, 1], [1, 2, 3], dtype: dtype)
+        NMatrix::BLAS.cblas_scal(3, 2, x, 1)
+        expect(x).to eq(NMatrix.new([3, 1], [2, 4, 6], dtype: dtype))
+      end
+
+      it "exposes cblas_imax" do
+        u = NMatrix.new([3,1], [1, 4, 3], dtype: dtype)
+        index = NMatrix::BLAS.cblas_imax(3, u, 1)
+        expect(index).to eq(1)
+      end
+    end
+  end
+
+  [:float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype 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(3, [4,-1.0/2, -3.0/4, -2, 2, -1.0/4, -4, -2, -1.0/2], dtype: dtype)
+        b     = NMatrix.new([3,1], [-1, 17, -9], dtype: dtype)
+        NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nonunit, 1, 3, 1.0, a, 3, b, 3)
+
+        # These test results all come from actually running a matrix through BLAS. We use them to ensure that NMatrix's
+        # version of these functions give similar results.
+
+        expect(b[0]).to eq(-1.0/4)
+        expect(b[1]).to eq(33.0/4)
+        expect(b[2]).to eq(-13)
+
+        NMatrix::BLAS::cblas_trsm(:row, :right, :upper, :transpose, :unit, 1, 3, 1.0, a, 3, b, 3)
+
+        expect(b[0]).to eq(-15.0/2)
+        expect(b[1]).to eq(5)
+        expect(b[2]).to eq(-13)
+        
+        NMatrix::BLAS::cblas_trsm(:row, :left, :lower, :transpose, :nounit, 3, 1, 1.0, a, 3, b, 1)
+
+        expect(b[0]).to eq(307.0/8)
+        expect(b[1]).to eq(57.0/2)
+        expect(b[2]).to eq(26.0)
+        
+        NMatrix::BLAS::cblas_trsm(:row, :left, :upper, :transpose, :unit, 3, 1, 1.0, a, 3, b, 1)
+
+        expect(b[0]).to eq(307.0/8)
+        expect(b[1]).to eq(763.0/16)
+        expect(b[2]).to eq(4269.0/64)        
+      end
+
+      # trmm multiplies two matrices, where one of the two is required to be
+      # triangular
+      it "exposes cblas_trmm" do
+        a = NMatrix.new([3,3], [1,1,1, 0,1,2, 0,0,-1], dtype: dtype)
+        b = NMatrix.new([3,3], [1,2,3, 4,5,6, 7,8,9], dtype: dtype)
+
+        begin
+          NMatrix::BLAS.cblas_trmm(:row, :left, :upper, false, :not_unit, 3, 3, 1, a, 3, b, 3)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        product = NMatrix.new([3,3], [12,15,18, 18,21,24, -7,-8,-9], dtype: dtype)
+        expect(b).to eq(product)
+      end
+    end
+  end
+
+  #should have a separate test for complex
+  [:float32, :float64, :complex64, :complex128, :object].each do |dtype|
+    context dtype do
+
+      it "exposes cblas rot" do
+        x = NMatrix.new([5,1], [1,2,3,4,5], dtype: dtype)
+        y = NMatrix.new([5,1], [-5,-4,-3,-2,-1], dtype: dtype)
+        x, y = NMatrix::BLAS::rot(x, y, 1.0/2, Math.sqrt(3)/2, -1)
+
+        expect(x).to be_within(1e-4).of(
+                   NMatrix.new([5,1], [-0.3660254037844386, -0.7320508075688772, -1.098076211353316, -1.4641016151377544, -1.8301270189221928], dtype: dtype)
+                 )
+
+        expect(y).to be_within(1e-4).of(
+                   NMatrix.new([5,1], [-6.830127018922193, -5.464101615137754, -4.098076211353316, -2.732050807568877, -1.3660254037844386], dtype: dtype)
+                 )
+      end
+
+    end
+  end
+
+  [:float32, :float64, :complex64, :complex128, :object].each do |dtype|
+    context dtype do
+
+      it "exposes cblas rotg" do
+        pending("broken for :object") if dtype == :object
+
+        ab = NMatrix.new([2,1], [6,-8], dtype: dtype)
+        begin
+          c,s = NMatrix::BLAS::rotg(ab)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        if [:float32, :float64].include?(dtype)
+          expect(ab[0]).to be_within(1e-6).of(-10)
+          expect(ab[1]).to be_within(1e-6).of(-5.0/3)
+          expect(c).to be_within(1e-6).of(-3.0/5)
+        else
+          pending "need correct test cases"
+          expect(ab[0]).to be_within(1e-6).of(10)
+          expect(ab[1]).to be_within(1e-6).of(5.0/3)
+          expect(c).to be_within(1e-6).of(3.0/5)
+        end
+        expect(s).to be_within(1e-6).of(4.0/5)
+      end
+
+      # Note: this exposes gemm, not cblas_gemm (which is the unfriendly CBLAS no-error-checking version)
+      it "exposes gemm" 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], dtype: dtype)
+        m = NMatrix.new([3,2], [12.0,25.0, 9.0,10.0, 8.0,5.0], dtype: dtype)
+
+        #c = NMatrix.new([4,2], dtype)
+        r = NMatrix::BLAS.gemm(n, m) #, c)
+        #c.should equal(r) # check that both are same memory address
+
+        expect(r).to eq(NMatrix.new([4,2], [273,455,243,235,244,205,102,160], dtype: dtype))
+      end
+
+      it "exposes gemv" do
+        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], dtype: dtype)
+        x = NMatrix.new([3,1], [2.0, 1.0, 0.0], dtype: dtype)
+        y = NMatrix::BLAS.gemv(a, x)
+        expect(y).to eq(NMatrix.new([4,1],[4.0,13.0,22.0,31.0],dtype: dtype))
+      end
+
+      it "exposes asum" do
+        pending("broken for :object") if dtype == :object
+
+        x = NMatrix.new([4,1], [-1,2,3,4], dtype: dtype)
+        expect(NMatrix::BLAS.asum(x)).to eq(10)
+      end
+
+      it "exposes asum for single element" do
+        if [:complex64,:complex128].include?(dtype)
+          x = NMatrix.new([1], [Complex(-3,2)], dtype: dtype)
+          expect(x.asum).to eq(5.0)
+        else
+          x = NMatrix.new([1], [-1], dtype: dtype)
+          expect(x.asum).to eq(1.0)
+        end
+      end
+
+      it "exposes nrm2" do
+        pending("broken for :object") if dtype == :object
+
+        if dtype =~ /complex/
+          x = NMatrix.new([3,1], [Complex(1,2),Complex(3,4),Complex(0,6)], dtype: dtype)
+          y = NMatrix.new([3,1], [Complex(0,0),Complex(0,0),Complex(0,0)], dtype: dtype)
+          nrm2 = 8.12403840463596
+        else
+          x = NMatrix.new([4,1], [2,-4,3,5], dtype: dtype)
+          y = NMatrix.new([3,1], [0,0,0], dtype: dtype)
+          nrm2 = 5.385164807134504
+        end
+        
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-14
+                else
+                  1e-14
+              end
+
+        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(err).of(nrm2)
+        expect(NMatrix::BLAS.nrm2(y, 1, 3)).to be_within(err).of(0)
+      end
+
+    end
+  end
+end

data/spec/elementwise_spec.rb

@@ -0,0 +1,311 @@
+# = 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
+#
+# == nmatrix_spec.rb
+#
+# Element-wise operation tests.
+#
+
+require 'spec_helper'
+
+describe NMatrix do
+  context "yale" do
+    before :each do
+      @n = NMatrix.new(3, stype: :yale, dtype: :int64)
+      @n.extend NMatrix::YaleFunctions unless jruby?
+      @m = NMatrix.new(3, stype: :yale, dtype: :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 unless jruby?
+    end
+
+    it "should perform scalar math" do
+      pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
+      x = @n * 3
+      expect(x[0,0]).to eq(52 * 3)
+      expect(x[0,1]).to eq(30 * 3)
+      expect(x[0,2]).to eq(5 * 3)
+      expect(x[1,1]).to eq(40 * 3)
+      expect(x[2,0]).to eq(6 * 3)
+
+      r = NMatrix.new(3, stype: :yale, dtype: :int64)
+      y = r + 3
+      expect(y[0,0]).to eq(3)
+    end
+
+    it "should refuse to perform a dot operation on a yale with non-zero default" do
+      pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
+      r = NMatrix.new(3, stype: :yale, dtype: :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
+      expect(@n+@m).to eq(NMatrix.new(:dense, 3, [52,30,0,0,-8,0,6,0,0], :int64).cast(:yale, :int64))
+    end
+
+    it "should perform element-wise subtraction" do
+      expect(@n-@m).to eq(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(2, stype: :yale, dtype: :int64)
+      expect(@n*@m).to eq(r)
+    end
+
+    it "should perform element-wise division" do
+      pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
+      r = NMatrix.new(:dense, 3, [52, 30, -2, 0, -1, 0, 6, 0, 0], :int64).cast(:yale, :int64)
+      expect(@n/(@m+1)).to eq(r)
+    end
+
+    it "should perform element-wise modulo" do
+      pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
+      m = NMatrix.new(3, stype: :yale, dtype: :int64, default: 0) + 5
+      expect(@n % m).to eq(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
+      expect(@n =~ @m).to eq(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
+      expect(@n !~ @m).to eq(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
+      expect(@m < @n).to eq(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
+      expect(@n > @m).to eq(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
+      expect(@n >= @m).to eq(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)
+      expect(@n <= @m).to eq(r)
+    end
+  end
+
+
+  context "list" do
+    before :each do
+      @n = NMatrix.new(:list, 2, 0, :int64)
+      @m = NMatrix.new(:list, 2, 0, :int64)
+      @n[0,0] = 52
+      @m[1,1] = -48
+      @n[1,1] = 40
+    end
+
+    it "should perform scalar math" do
+      pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
+      x = @n * 3
+      expect(x[0,0]).to eq(52 * 3)
+      expect(x[1,1]).to eq(40 * 3)
+      expect(x[0,1]).to eq(0)
+
+      r = NMatrix.new(3, stype: :list, default: 1)
+      y = r + 3
+      expect(y[0,0]).to eq(4)
+    end
+
+    it "should perform element-wise addition" do
+      r = NMatrix.new(2, stype: :list, dtype: :int64, default: 0)
+      r[0,0] = 52
+      r[1,1] = -8
+      q = @n + @m
+      expect(q).to eq(r)
+    end
+
+    it "should perform element-wise subtraction" do
+      r = NMatrix.new(:dense, 2, [52, 0, 0, 88], :int64).cast(:list, :int64)
+      expect(@n-@m).to eq(r)
+    end
+
+    it "should perform element-wise multiplication" do
+      r = NMatrix.new(:dense, 2, [52, 0, 0, -1920], :int64).cast(:list, :int64)
+      m = NMatrix.new(:list, 2, 1, :int64)
+      m[1,1] = -48
+      expect(@n*m).to eq(r)
+    end
+
+    it "should perform element-wise division" do
+      m = NMatrix.new(:list, 2, 1, :int64)
+      m[1,1] = 2
+      r = NMatrix.new(:dense, 2, [52, 0, 0, 20], :int64).cast(:list, :int64)
+      expect(@n/m).to eq(r)
+    end
+
+    it "should perform element-wise modulo" do
+      pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
+      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
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,1] = true
+      r[1,0] = true
+
+      expect(@n =~ @m).to eq(r)
+    end
+
+    it "should handle element-wise inequality (!~)" do
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,0] = true
+      r[1,1] = true
+
+      expect(@n !~ @m).to eq(r)
+    end
+
+    it "should handle element-wise less-than (<)" do
+      expect(@n < @m).to eq(NMatrix.new(:list, 2, false, :object))
+    end
+
+    it "should handle element-wise greater-than (>)" do
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,0] = true
+      r[1,1] = true
+      expect(@n > @m).to eq(r)
+    end
+
+    it "should handle element-wise greater-than-or-equals (>=)" do
+      expect(@n >= @m).to eq(NMatrix.new(:list, 2, true, :object))
+    end
+
+    it "should handle element-wise less-than-or-equals (<=)" do
+      r = NMatrix.new(:list, 2, false, :object)
+      r[0,1] = true
+      r[1,0] = true
+      expect(@n <= @m).to eq(r)
+    end
+  end
+
+  context "dense" do
+    context "scalar arithmetic" do
+      before :each do
+        @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
+      end
+
+      it "works for integers" do
+        expect(@n+1).to eq(NMatrix.new(:dense, 2, [2,3,4,5], :int64))
+      end
+
+      #it "works for complex64" do
+      #  n = @n.cast(:dtype => :complex64)
+      #  (n + 10.0).to_a.should == [Complex(11.0), Complex(12.0), Complex(13.0), Complex(14.0)]
+      #end
+    end
+
+    context "elementwise arithmetic" do
+      before :each do
+        @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
+        @m = NMatrix.new(:dense, 2, [-4,-1,0,66], :int64)
+      end
+
+      it "adds" do
+        r = @n+@m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [-3, 1, 3, 70], :int64))
+      end
+
+      it "subtracts" do
+        r = @n-@m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [5, 3, 3, -62], :int64))
+      end
+
+      it "multiplies" do
+        r = @n*@m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [-4, -2, 0, 264], :int64))
+      end
+
+      it "divides in the Ruby way" do
+        pending("not yet implemented int dtype for NMatrix-JRuby") if jruby?
+        m = @m.clone
+        m[1,0] = 3
+        r = @n/m
+        expect(r).to eq(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.
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [1, 4, 9, 16], :int64))
+      end
+
+      it "modulo" do
+        pending("not yet implemented int dtype for NMatrix-JRuby") if jruby?
+        expect(@n % (@m + 2)).to eq(NMatrix.new(:dense, [2,2], [-1, 0, 1, 4], :int64))
+      end
+    end
+
+    context "elementwise comparisons" do
+      before :each do
+        @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
+        @m = NMatrix.new(:dense, 2, [-4,-1,3,2], :int64)
+      end
+
+      it "equals" do
+        r = @n =~ @m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [false, false, true, false], :object))
+      end
+
+      it "is not equal" do
+        r = @n !~ @m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [true, true, false, true], :object))
+      end
+
+      it "is less than" do
+        r = @n < @m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], false, :object))
+      end
+
+      it "is greater than" do
+        r = @n > @m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [true, true, false, true], :object))
+      end
+
+      it "is less than or equal to" do
+        r = @n <= @m
+        expect(r).to eq(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)
+        r = n >= @m
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [true, true, false, true], :object))
+      end
+    end
+  end
+end

data/spec/homogeneous_spec.rb

@@ -0,0 +1,100 @@
+# = 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
+#
+# == homogeneous_spec.rb
+#
+# Specs for the homogeneous transformation matrix methods.
+#
+
+require 'spec_helper'
+require "./lib/nmatrix/homogeneous.rb"
+
+require 'pry'
+
+describe 'NMatrix' do
+  context ".x_rotation" do
+    it "should generate a matrix representing a rotation about the x axis" do
+      x = NMatrix.x_rotation(Math::PI/6)
+      expect(x).to be_within(1e-8).of(NMatrix.new([4,4], [1.0, 0.0, 0.0, 0.0,
+                                                      0.0, Math.cos(Math::PI/6), -0.5, 0.0,
+                                                      0.0, 0.5, Math.cos(Math::PI/6), 0.0,
+                                                      0.0, 0.0, 0.0, 1.0] ))
+    end
+  end
+
+
+  context ".y_rotation" do
+    it "should generate a matrix representing a rotation about the y axis" do
+      y = NMatrix.y_rotation(Math::PI/6)
+      expect(y).to be_within(1e-8).of(NMatrix.new([4,4], [Math.cos(Math::PI/6), 0.0, 0.5, 0.0,
+                                                      0.0, 1.0, 0.0, 0.0,
+                                                     -0.5, 0.0, Math.cos(Math::PI/6), 0.0,
+                                                      0.0, 0.0, 0.0, 1.0] ))
+    end
+  end
+
+  context ".z_rotation" do
+    it "should generate a matrix representing a rotation about the z axis" do
+      z = NMatrix.z_rotation(Math::PI/6)
+      expect(z).to be_within(1e-8).of(NMatrix.new([4,4], [Math.cos(Math::PI/6), -0.5, 0.0, 0.0,
+                                                      0.5, Math.cos(Math::PI/6), 0.0, 0.0,
+                                                      0.0, 0.0, 1.0, 0.0,
+                                                      0.0, 0.0, 0.0, 1.0] ))
+    end
+  end
+
+  context ".translation" do
+    it "should generate a translation matrix from an Array" do
+      t = NMatrix.translation([4,5,6])
+      expect(t).to be_within(1e-8).of(NMatrix.new([4,4], [1, 0, 0, 4,
+                                                      0, 1, 0, 5,
+                                                      0, 0, 1, 6,
+                                                      0, 0, 0, 1] ))
+    end
+
+    it "should generate a translation matrix from x, y, and z values" do
+      t = NMatrix.translation(4,5,6)
+      expect(t).to be_within(1e-8).of(NMatrix.new([4,4], [1, 0, 0, 4,
+                                                      0, 1, 0, 5,
+                                                      0, 0, 1, 6,
+                                                      0, 0, 0, 1] ))
+    end
+
+    it "should generate a translation matrix from an NMatrix with correctly inferred dtype" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
+      t = NMatrix.translation(NMatrix.new([3,1], [4,5,6], dtype: :float64) )
+      expect(t).to be_within(1e-8).of(NMatrix.new([4,4], [1, 0, 0, 4,
+                                                      0, 1, 0, 5,
+                                                      0, 0, 1, 6,
+                                                      0, 0, 0, 1] ))
+      expect(t.dtype).to be(:float64)
+    end
+  end
+
+  context "#quaternion" do
+    it "should generate a singularity-free quaternion" do
+      transform = NMatrix.new([4,4], [-0.9995825,-0.02527934,-0.0139845,50.61761,-0.02732551,0.9844284,0.1736463,-22.95566,0.009376526,0.1739562,-0.9847089,7.1521,0,0,0,1])
+      q = transform.quaternion
+      expect(Math.sqrt(q[0]**2 + q[1]**2 + q[2]**2 + q[3]**2)).to be_within(1e-6).of(1.0)
+    end
+  end
+end