nmatrix 0.1.0 → 0.2.0

data/spec/02_slice_spec.rb

@@ -258,8 +258,8 @@ describe "Slice operation" do
         end
 
         if stype == :dense
-          [: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|
+          [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |left_dtype|
+            [:byte,:int8,:int16,:int32,:int64,:float32,:float64].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)
@@ -272,16 +272,12 @@ describe "Slice operation" do
 
                 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

data/spec/03_nmatrix_monkeys_spec.rb

@@ -59,7 +59,7 @@ describe Array do
 
     it "intuits shape of Array into multiple dimensions" do
       a = [[[0], [1]], [[2], [3]], [[4], [5]]]
-      expect(a.to_nm).to eq(NMatrix.new([3,1,2], a.flatten))
+      expect(a.to_nm).to eq(NMatrix.new([3,2,1], a.flatten))
       expect(a).to eq(a.to_nm.to_a)
     end
 
@@ -67,6 +67,12 @@ describe Array do
       a = [[0, 1, 2], [3], [4, 5]]
       expect(a).to eq(a.to_nm.to_a)
     end
+
+    it "does not permanently alter the Array" do
+      a = [[0, 1], [2, 3], [4, 5]]
+      expect(a.to_nm).to eq(NMatrix.new([3,2], a.flatten))
+      expect(a).to eq([[0, 1], [2, 3], [4, 5]])
+    end
   end
 end
 

data/spec/blas_spec.rb

@@ -30,7 +30,6 @@ require 'spec_helper'
 describe NMatrix::BLAS do
   [:byte, :int8, :int16, :int32, :int64,
    :float32, :float64, :complex64, :complex128,
-   :rational32, :rational64, :rational128,
    :object
   ].each do |dtype|
     context dtype do
@@ -48,49 +47,56 @@ describe NMatrix::BLAS do
     end
   end
 
-  [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
+  [: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.quo(2), -3.quo(4), -2, 2, -1.quo(4), -4, -2, -1.quo(2)], dtype: dtype)
+        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 (for rationals) give similar results.
+        # version of these functions give similar results.
 
-        expect(b[0]).to eq(-1.quo(4))
-        expect(b[1]).to eq(33.quo(4))
+        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.quo(2))
+        expect(b[0]).to eq(-15.0/2)
         expect(b[1]).to eq(5)
         expect(b[2]).to eq(-13)
       end
-    end
-  end
 
-  [:rational32,:rational64,:rational128].each do |dtype|
-    context dtype do
-      it "exposes cblas rot"
-    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)
 
-    context dtype do
-      it "exposes cblas rotg"
+        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.quo(2), Math.sqrt(3).quo(2), -1)
+        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)
@@ -111,19 +117,23 @@ describe NMatrix::BLAS do
         pending("broken for :object") if dtype == :object
 
         ab = NMatrix.new([2,1], [6,-8], dtype: dtype)
-        c,s = NMatrix::BLAS::rotg(ab)
+        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.quo(3))
-          expect(c).to be_within(1e-6).of(-3.quo(5))
+          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.quo(3))
-          expect(c).to be_within(1e-6).of(3.quo(5))
+          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.quo(5))
+        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)
@@ -138,27 +148,44 @@ describe NMatrix::BLAS do
         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: :float64)
-        x = NMatrix.new([3,1], [2.0, 1.0, 0.0], dtype: :float64)
-
-        NMatrix::BLAS.gemv(a, x)
+        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
-        x = NMatrix.new([4,1], [1,2,3,4], dtype: :float64)
-        expect(NMatrix::BLAS.asum(x)).to eq(10.0)
+        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
-        x = NMatrix.new([1], [-1], dtype: :float64)
-        expect(x.asum).to eq(1.0)
+        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
-        x = NMatrix.new([4,1], [2,-4,3,5], dtype: :float64)
-        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(1e-10).of(5.385164807134504)
+        pending("broken for :object") if dtype == :object
+        pending("Temporarily disable because the internal implementation of nrm2 is broken -WL 2015-05-17") if dtype == :complex64 || dtype == :complex128
+
+        x = NMatrix.new([4,1], [2,-4,3,5], dtype: dtype)
+        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(5.385164807134504)
       end
 
     end

data/spec/homogeneous_spec.rb

@@ -33,10 +33,10 @@ 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.quo(6))
+      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.quo(6)), -0.5, 0.0,
-                                                      0.0, 0.5, Math.cos(Math::PI.quo(6)), 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
@@ -44,19 +44,19 @@ describe 'NMatrix' do
 
   context ".y_rotation" do
     it "should generate a matrix representing a rotation about the y axis" do
-      y = NMatrix.y_rotation(Math::PI.quo(6))
-      expect(y).to be_within(1e-8).of(NMatrix.new([4,4], [Math.cos(Math::PI.quo(6)), 0.0, 0.5, 0.0,
+      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.quo(6)), 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.quo(6))
-      expect(z).to be_within(1e-8).of(NMatrix.new([4,4], [Math.cos(Math::PI.quo(6)), -0.5, 0.0, 0.0,
-                                                      0.5, Math.cos(Math::PI.quo(6)), 0.0, 0.0,
+      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
@@ -96,4 +96,4 @@ describe 'NMatrix' do
       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
+end

data/spec/lapack_core_spec.rb

@@ -0,0 +1,482 @@
+# = 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
+#
+# == lapack_core_spec.rb
+#
+# Tests for LAPACK functions that have internal implementations (i.e. they
+# don't rely on external libraries) and also functions that are implemented
+# by both nmatrix-atlas and nmatrix-lapacke. These tests will also be run for the
+# plugins that do use external libraries, since they will override the
+# internal implmentations.
+#
+
+require 'spec_helper'
+
+describe "NMatrix::LAPACK functions with internal implementations" do
+  # where integer math is allowed
+  [:byte, :int8, :int16, :int32, :int64, :float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+      # This spec seems a little weird. It looks like laswp ignores the last
+      # element of piv, though maybe I misunderstand smth. It would make
+      # more sense if piv were [2,1,3,3]
+      it "exposes clapack laswp" do
+        a = NMatrix.new(:dense, [3,4], [1,2,3,4,5,6,7,8,9,10,11,12], dtype)
+        NMatrix::LAPACK::clapack_laswp(3, a, 4, 0, 3, [2,1,3,0], 1)
+        b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
+        expect(a).to eq(b)
+      end
+
+      # This spec is OK, because the default behavior for permute_columns
+      # is :intuitive, which is different from :lapack (default laswp behavior)
+      it "exposes NMatrix#permute_columns and #permute_columns! (user-friendly laswp)" do
+        a = NMatrix.new(:dense, [3,4], [1,2,3,4,5,6,7,8,9,10,11,12], dtype)
+        b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
+        piv = [2,1,3,0]
+        r = a.permute_columns(piv)
+        expect(r).not_to eq(a)
+        expect(r).to eq(b)
+        a.permute_columns!(piv)
+        expect(a).to eq(b)
+      end
+    end
+  end
+
+  # where integer math is not allowed
+  [:float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+
+      # clapack_getrf performs a LU decomposition, but unlike the
+      # standard LAPACK getrf, it's the upper matrix that has unit diagonals
+      # and the permutation is done in columns not rows. See the code for
+      # details.
+      # Also the rows in the pivot vector are indexed starting from 0,
+      # rather than 1 as in LAPACK
+      it "calculates LU decomposition using clapack_getrf (row-major, square)" do
+        a = NMatrix.new(3, [4,9,2,3,5,7,8,1,6], dtype: dtype)
+        ipiv = NMatrix::LAPACK::clapack_getrf(:row, a.shape[0], a.shape[1], a, a.shape[1])
+        b = NMatrix.new(3,[9, 2.0/9, 4.0/9,
+                           5, 53.0/9, 7.0/53,
+                           1, 52.0/9, 360.0/53], dtype: dtype)
+        ipiv_true = [1,2,2]
+
+        # delta varies for different dtypes
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(a).to be_within(err).of(b)
+        expect(ipiv).to eq(ipiv_true)
+      end
+
+      it "calculates LU decomposition using clapack_getrf (row-major, rectangular)" do
+        a = NMatrix.new([3,4], GETRF_EXAMPLE_ARRAY, dtype: dtype)
+        ipiv = NMatrix::LAPACK::clapack_getrf(:row, a.shape[0], a.shape[1], a, a.shape[1])
+        #we can't use GETRF_SOLUTION_ARRAY here, because of the different
+        #conventions of clapack_getrf
+        b = NMatrix.new([3,4],[10.0, -0.1,      0.0,       0.4,
+                               3.0,   9.3,  20.0/93,   38.0/93,
+                               1.0,   7.1, 602.0/93, 251.0/602], dtype: dtype)
+        ipiv_true = [2,2,2]
+
+        # delta varies for different dtypes
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(a).to be_within(err).of(b)
+        expect(ipiv).to eq(ipiv_true)
+      end
+
+      #Normally we wouldn't check column-major routines, since all our matrices
+      #are row-major, but we use the column-major version in #getrf!, so we
+      #want to test it here.
+      it "calculates LU decomposition using clapack_getrf (col-major, rectangular)" do
+        #this is supposed to represent the 3x2 matrix
+        # -1  2
+        #  0  3
+        #  1 -2
+        a = NMatrix.new([1,6], [-1,0,1,2,3,-2], dtype: dtype)
+        ipiv = NMatrix::LAPACK::clapack_getrf(:col, 3, 2, a, 3)
+        b = NMatrix.new([1,6], [-1,0,-1,2,3,0], dtype: dtype)
+        ipiv_true = [0,1]
+
+        # delta varies for different dtypes
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(a).to be_within(err).of(b)
+        expect(ipiv).to eq(ipiv_true)
+      end
+
+      it "calculates LU decomposition using #getrf! (rectangular)" do
+        a = NMatrix.new([3,4], GETRF_EXAMPLE_ARRAY, dtype: dtype)
+        ipiv = a.getrf!
+        b = NMatrix.new([3,4], GETRF_SOLUTION_ARRAY, dtype: dtype)
+        ipiv_true = [2,3,3]
+
+        # delta varies for different dtypes
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(a).to be_within(err).of(b)
+        expect(ipiv).to eq(ipiv_true)
+      end
+
+      it "calculates LU decomposition using #getrf! (square)" do
+        a = NMatrix.new([4,4], [0,1,2,3, 1,1,1,1, 0,-1,-2,0, 0,2,0,2], dtype: dtype)
+        ipiv = a.getrf!
+
+        b = NMatrix.new([4,4], [1,1,1,1, 0,2,0,2, 0,-0.5,-2,1, 0,0.5,-1,3], dtype: dtype)
+        ipiv_true = [2,4,3,4]
+
+        expect(a).to eq(b)
+        expect(ipiv).to eq(ipiv_true)
+      end
+
+      # Together, these calls are basically xGESV from LAPACK: http://www.netlib.org/lapack/double/dgesv.f
+      it "exposes clapack_getrs" do
+        a     = NMatrix.new(3, [-2,4,-3, 3,-2,1, 0,-4,3], dtype: dtype)
+        ipiv  = NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3)
+        b     = NMatrix.new([3,1], [-1, 17, -9], dtype: dtype)
+
+        NMatrix::LAPACK::clapack_getrs(:row, false, 3, 1, a, 3, ipiv, b, 3)
+
+        expect(b[0]).to eq(5)
+        expect(b[1]).to eq(-15.0/2)
+        expect(b[2]).to eq(-13)
+      end
+
+      it "solves matrix equation (non-vector rhs) using clapack_getrs" do
+        a     = NMatrix.new(3, [-2,4,-3, 3,-2,1, 0,-4,3], dtype: dtype)
+        b     = NMatrix.new([3,2], [-1,2, 17,1, -9,-4], dtype: dtype)
+
+        n = a.shape[0]
+        nrhs = b.shape[1]
+
+        ipiv  = NMatrix::LAPACK::clapack_getrf(:row, n, n, a, n)
+        # Even though we pass :row to clapack_getrs, it still interprets b as
+        # column-major, so need to transpose b before and after:
+        b = b.transpose
+        NMatrix::LAPACK::clapack_getrs(:row, false, n, nrhs, a, n, ipiv, b, n)
+        b = b.transpose
+
+        b_true = NMatrix.new([3,2], [5,1, -7.5,1, -13,0], dtype: dtype)
+        expect(b).to eq(b_true)
+      end
+
+      #posv is like potrf+potrs
+      #posv is implemented in both nmatrix-atlas and nmatrix-lapacke, so the spec
+      #needs to be shared here
+      it "solves a (symmetric positive-definite) matrix equation using posv (vector rhs)" do
+        a = NMatrix.new(3, [4, 0,-1,
+                            0, 2, 1,
+                            0, 0, 1], dtype: dtype)
+        b = NMatrix.new([3,1], [4,2,0], dtype: dtype)
+
+        begin
+          x = NMatrix::LAPACK::posv(:upper, a, b)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        x_true = NMatrix.new([3,1], [1, 1, 0], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(x).to be_within(err).of(x_true)
+      end
+
+      it "solves a (symmetric positive-definite) matrix equation using posv (non-vector rhs)" do
+        a = NMatrix.new(3, [4, 0,-1,
+                            0, 2, 1,
+                            0, 0, 1], dtype: dtype)
+        b = NMatrix.new([3,2], [4,-1, 2,-1, 0,0], dtype: dtype)
+
+        begin
+          x = NMatrix::LAPACK::posv(:upper, a, b)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        x_true = NMatrix.new([3,2], [1,0, 1,-1, 0,1], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(x).to be_within(err).of(x_true)
+      end
+
+      it "calculates the singular value decomposition with NMatrix#gesvd" do
+        #example from Wikipedia
+        m = 4
+        n = 5
+        mn_min = [m,n].min
+        a = NMatrix.new([m,n],[1,0,0,0,2, 0,0,3,0,0, 0,0,0,0,0, 0,4,0,0,0], dtype: dtype)
+
+        begin
+          u, s, vt = a.gesvd
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        s_true = NMatrix.new([mn_min,1], [4,3,Math.sqrt(5),0], dtype: a.abs_dtype)
+        u_true = NMatrix.new([m,m], [0,0,1,0, 0,1,0,0, 0,0,0,-1, 1,0,0,0], dtype: dtype)
+        vt_true = NMatrix.new([n,n], [0,1,0,0,0, 0,0,1,0,0, Math.sqrt(0.2),0,0,0,Math.sqrt(0.8), 0,0,0,1,0, -Math.sqrt(0.8),0,0,0,Math.sqrt(0.2)], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(s).to be_within(err).of(s_true)
+        expect(u).to be_within(err).of(u_true)
+        expect(vt).to be_within(err).of(vt_true)
+
+        expect(s.dtype).to eq(a.abs_dtype)
+        expect(u.dtype).to eq(dtype)
+        expect(vt.dtype).to eq(dtype)
+      end
+
+      it "calculates the singular value decomposition with NMatrix#gesdd" do
+        #example from Wikipedia
+        m = 4
+        n = 5
+        mn_min = [m,n].min
+        a = NMatrix.new([m,n],[1,0,0,0,2, 0,0,3,0,0, 0,0,0,0,0, 0,4,0,0,0], dtype: dtype)
+
+        begin
+          u, s, vt = a.gesdd
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        s_true = NMatrix.new([mn_min,1], [4,3,Math.sqrt(5),0], dtype: a.abs_dtype)
+        u_true = NMatrix.new([m,m], [0,0,1,0, 0,1,0,0, 0,0,0,-1, 1,0,0,0], dtype: dtype)
+        vt_true = NMatrix.new([n,n], [0,1,0,0,0, 0,0,1,0,0, Math.sqrt(0.2),0,0,0,Math.sqrt(0.8), 0,0,0,1,0, -Math.sqrt(0.8),0,0,0,Math.sqrt(0.2)], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(s).to be_within(err).of(s_true)
+        expect(u).to be_within(err).of(u_true)
+        expect(vt).to be_within(err).of(vt_true)
+      end
+
+
+      it "calculates eigenvalues and eigenvectors NMatrix::LAPACK.geev (real matrix, complex eigenvalues)" do
+        n = 3
+        a = NMatrix.new([n,n], [-1,0,0, 0,1,-2, 0,1,-1], dtype: dtype)
+
+        begin
+          eigenvalues, vl, vr = NMatrix::LAPACK.geev(a)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        eigenvalues_true = NMatrix.new([n,1], [Complex(0,1), -Complex(0,1), -1], dtype: NMatrix.upcast(dtype, :complex64))
+        vr_true = NMatrix.new([n,n],[0,0,1,
+                                     2/Math.sqrt(6),2/Math.sqrt(6),0,
+                                     Complex(1,-1)/Math.sqrt(6),Complex(1,1)/Math.sqrt(6),0], dtype: NMatrix.upcast(dtype, :complex64))
+        vl_true = NMatrix.new([n,n],[0,0,1,
+                                     Complex(-1,1)/Math.sqrt(6),Complex(-1,-1)/Math.sqrt(6),0,
+                                     2/Math.sqrt(6),2/Math.sqrt(6),0], dtype: NMatrix.upcast(dtype, :complex64))
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(eigenvalues).to be_within(err).of(eigenvalues_true)
+        expect(vr).to be_within(err).of(vr_true)
+        expect(vl).to be_within(err).of(vl_true)
+
+        expect(eigenvalues.dtype).to eq(NMatrix.upcast(dtype, :complex64))
+        expect(vr.dtype).to eq(NMatrix.upcast(dtype, :complex64))
+        expect(vl.dtype).to eq(NMatrix.upcast(dtype, :complex64))
+      end
+
+      it "calculates eigenvalues and eigenvectors NMatrix::LAPACK.geev (real matrix, real eigenvalues)" do
+        n = 3
+        a = NMatrix.new([n,n], [2,0,0, 0,3,2, 0,1,2], dtype: dtype)
+
+        begin
+          eigenvalues, vl, vr = NMatrix::LAPACK.geev(a)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        eigenvalues_true = NMatrix.new([n,1], [1, 4, 2], dtype: dtype)
+
+        # For some reason, some of the eigenvectors have different signs
+        # when we use the complex versions of geev. This is totally fine, since
+        # they are still normalized eigenvectors even with the sign flipped.
+        if a.complex_dtype?
+          vr_true = NMatrix.new([n,n],[0,0,1,
+                                       1/Math.sqrt(2),2/Math.sqrt(5),0,
+                                       -1/Math.sqrt(2),1/Math.sqrt(5),0], dtype: dtype)
+          vl_true = NMatrix.new([n,n],[0,0,1,
+                                       -1/Math.sqrt(5),1/Math.sqrt(2),0,
+                                       2/Math.sqrt(5),1/Math.sqrt(2),0], dtype: dtype)
+        else
+          vr_true = NMatrix.new([n,n],[0,0,1,
+                                       1/Math.sqrt(2),-2/Math.sqrt(5),0,
+                                       -1/Math.sqrt(2),-1/Math.sqrt(5),0], dtype: dtype)
+          vl_true = NMatrix.new([n,n],[0,0,1,
+                                       1/Math.sqrt(5),-1/Math.sqrt(2),0,
+                                       -2/Math.sqrt(5),-1/Math.sqrt(2),0], dtype: dtype)
+        end
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(eigenvalues).to be_within(err).of(eigenvalues_true)
+        expect(vr).to be_within(err).of(vr_true)
+        expect(vl).to be_within(err).of(vl_true)
+
+        expect(eigenvalues.dtype).to eq(dtype)
+        expect(vr.dtype).to eq(dtype)
+        expect(vl.dtype).to eq(dtype)
+      end
+
+      it "calculates eigenvalues and eigenvectors NMatrix::LAPACK.geev (left eigenvectors only)" do
+        n = 3
+        a = NMatrix.new([n,n], [-1,0,0, 0,1,-2, 0,1,-1], dtype: dtype)
+
+        begin
+          eigenvalues, vl = NMatrix::LAPACK.geev(a, :left)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        eigenvalues_true = NMatrix.new([n,1], [Complex(0,1), -Complex(0,1), -1], dtype: NMatrix.upcast(dtype, :complex64))
+        vl_true = NMatrix.new([n,n],[0,0,1,
+                                     Complex(-1,1)/Math.sqrt(6),Complex(-1,-1)/Math.sqrt(6),0,
+                                     2/Math.sqrt(6),2/Math.sqrt(6),0], dtype: NMatrix.upcast(dtype, :complex64))
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(eigenvalues).to be_within(err).of(eigenvalues_true)
+        expect(vl).to be_within(err).of(vl_true)
+      end
+
+      it "calculates eigenvalues and eigenvectors NMatrix::LAPACK.geev (right eigenvectors only)" do
+        n = 3
+        a = NMatrix.new([n,n], [-1,0,0, 0,1,-2, 0,1,-1], dtype: dtype)
+
+        begin
+          eigenvalues, vr = NMatrix::LAPACK.geev(a, :right)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        eigenvalues_true = NMatrix.new([n,1], [Complex(0,1), -Complex(0,1), -1], dtype: NMatrix.upcast(dtype, :complex64))
+        vr_true = NMatrix.new([n,n],[0,0,1,
+                                     2/Math.sqrt(6),2/Math.sqrt(6),0,
+                                     Complex(1,-1)/Math.sqrt(6),Complex(1,1)/Math.sqrt(6),0], dtype: NMatrix.upcast(dtype, :complex64))
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(eigenvalues).to be_within(err).of(eigenvalues_true)
+        expect(vr).to be_within(err).of(vr_true)
+      end
+    end
+  end
+
+  [:complex64, :complex128].each do |dtype|
+    context dtype do
+      it "calculates eigenvalues and eigenvectors NMatrix::LAPACK.geev (complex matrix)" do
+        n = 3
+        a = NMatrix.new([n,n], [Complex(0,1),0,0, 0,3,2, 0,1,2], dtype: dtype)
+
+        begin
+          eigenvalues, vl, vr = NMatrix::LAPACK.geev(a)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        eigenvalues_true = NMatrix.new([n,1], [1, 4, Complex(0,1)], dtype: dtype)
+        vr_true = NMatrix.new([n,n],[0,0,1,
+                                     1/Math.sqrt(2),2/Math.sqrt(5),0,
+                                     -1/Math.sqrt(2),1/Math.sqrt(5),0], dtype: dtype)
+        vl_true = NMatrix.new([n,n],[0,0,1,
+                                     -1/Math.sqrt(5),1/Math.sqrt(2),0,
+                                     2/Math.sqrt(5),1/Math.sqrt(2),0], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(eigenvalues).to be_within(err).of(eigenvalues_true)
+        expect(vr).to be_within(err).of(vr_true)
+        expect(vl).to be_within(err).of(vl_true)
+      end
+    end
+  end
+end