nmatrix-fftw 0.2.1

data/spec/homogeneous_spec.rb

@@ -0,0 +1,99 @@
+# = 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
+      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

data/spec/io/fortran_format_spec.rb

@@ -0,0 +1,88 @@
+# = 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
+#
+# == fortran_format_spec.rb
+#
+# Basic tests for NMatrix::IO::FortranFormat.
+#
+
+require './lib/nmatrix'
+
+describe NMatrix::IO::FortranFormat do
+  it "parses integer FORTRAN formats" do
+    int_fmt =  NMatrix::IO::FortranFormat::Reader.new('(16I5)').parse
+
+    expect(int_fmt[:format_code]).to eq "INT_ID"
+    expect(int_fmt[:repeat])     .to eq 16
+    expect(int_fmt[:field_width]).to eq 5    
+
+    int_fmt = NMatrix::IO::FortranFormat::Reader.new('(I4)').parse 
+
+    expect(int_fmt[:format_code]).to eq "INT_ID"
+    expect(int_fmt[:field_width]).to eq 4
+  end
+
+  it "parses floating point FORTRAN formats" do
+    fp_fmt = NMatrix::IO::FortranFormat::Reader.new('(10F7.1)').parse
+
+    expect(fp_fmt[:format_code])       .to eq "FP_ID"
+    expect(fp_fmt[:repeat])            .to eq 10
+    expect(fp_fmt[:field_width])       .to eq 7
+    expect(fp_fmt[:post_decimal_width]).to eq 1
+
+    fp_fmt = NMatrix::IO::FortranFormat::Reader.new('(F4.2)').parse
+
+    expect(fp_fmt[:format_code])       .to eq "FP_ID"
+    expect(fp_fmt[:field_width])       .to eq 4
+    expect(fp_fmt[:post_decimal_width]).to eq 2
+  end
+
+  it "parses exponential FORTRAN formats" do
+    exp_fmt = NMatrix::IO::FortranFormat::Reader.new('(2E8.3E3)').parse
+
+    expect(exp_fmt[:format_code])       .to eq "EXP_ID"
+    expect(exp_fmt[:repeat])            .to eq 2
+    expect(exp_fmt[:field_width])       .to eq 8
+    expect(exp_fmt[:post_decimal_width]).to eq 3
+    expect(exp_fmt[:exponent_width])    .to eq 3
+
+    exp_fmt = NMatrix::IO::FortranFormat::Reader.new('(3E3.6)').parse
+
+    expect(exp_fmt[:format_code])       .to eq "EXP_ID"
+    expect(exp_fmt[:repeat])            .to eq 3
+    expect(exp_fmt[:field_width])       .to eq 3
+    expect(exp_fmt[:post_decimal_width]).to eq 6
+
+    exp_fmt = NMatrix::IO::FortranFormat::Reader.new('(E4.5)').parse
+    expect(exp_fmt[:format_code])       .to eq "EXP_ID"
+    expect(exp_fmt[:field_width])       .to eq 4
+    expect(exp_fmt[:post_decimal_width]).to eq 5
+  end
+
+  ['I3', '(F4)', '(E3.', '(E4.E5)'].each do |bad_format|
+    it "doesn't let bad input through : #{bad_format}" do
+      expect {
+        NMatrix::IO::FortranFormat::Reader.new(bad_format).parse
+      }.to raise_error(IOError)
+  end
+end
+end

data/spec/io/harwell_boeing_spec.rb

@@ -0,0 +1,98 @@
+# = 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
+#
+# == io_spec.rb
+#
+# Basic tests for NMatrix::IO::HarwelBoeing.
+
+# TODO : After the fortran format thing is done
+require 'spec_helper'
+require "./lib/nmatrix"
+
+describe NMatrix::IO::HarwellBoeing do
+  def check_file_header header
+    expect(header[:title])    .to eq("Title")
+    expect(header[:key])      .to eq("Key")
+
+    expect(header[:totcrd])   .to eq(5)
+    expect(header[:ptrcrd])   .to eq(1)
+    expect(header[:indcrd])   .to eq(1)
+    expect(header[:valcrd])   .to eq(3)
+    expect(header[:rhscrd])   .to eq(0)
+    
+    expect(header[:mxtype])   .to eq('RUA')
+    expect(header[:nrow])     .to eq(5)
+    expect(header[:ncol])     .to eq(5)
+    expect(header[:nnzero])   .to eq(13)
+    expect(header[:neltvl])   .to eq(0)
+
+    expect(header[:ptrfmt])   .to eq({
+      format_code: "INT_ID",
+      repeat:             6,         
+      field_width:        3
+      })
+    expect(header[:indfmt])   .to eq({
+      format_code: "INT_ID",
+      repeat:            13,
+      field_width:       3
+      })
+    expect(header[:valfmt])   .to eq({
+      format_code:         "EXP_ID",
+      repeat:                     5,
+      field_width:               15,
+      post_decimal_width:         8
+      })
+    expect(header[:rhsfmt])   .to eq({
+      format_code:         "EXP_ID",
+      repeat:                     5,
+      field_width:               15,
+      post_decimal_width:         8
+      })
+  end
+
+  it "loads a Harwell Boeing file values and header (currently real only)" do
+    n, h = NMatrix::IO::HarwellBoeing.load("spec/io/test.rua")
+
+    expect(n.is_a? NMatrix).to eq(true)
+    expect(n.cols)         .to eq(5)
+    expect(n.rows)         .to eq(5)
+
+    expect(n[0,0])         .to eq(11)
+    expect(n[4,4])         .to eq(55)
+
+    expect(h.is_a? Hash).to eq(true) 
+    check_file_header(h)
+  end
+
+  it "loads only the header of the file when specified" do
+    h = NMatrix::IO::HarwellBoeing.load("spec/io/test.rua", header: true)
+
+    expect(h.is_a? Hash).to eq(true)
+    check_file_header(h)
+  end
+
+  it "raises error for wrong Harwell Boeing file name" do
+    expect{
+      NMatrix::IO::HarwellBoeing.load("spec/io/wrong.afx")
+    }.to raise_error(IOError)
+  end
+end

data/spec/io/test.rua

@@ -0,0 +1,9 @@
+Title                                                                   Key     
+             5             1             1             3             0
+RUA                        5             5            13             0
+(6I3)           (13I3)          (5E15.8)            (5E15.8)            
+  1  4  7  8 11 14
+  1  3  5  2  3  5  3  1  3  4  3  4  5
+11.0           31.0           51.0           22.0           32.0
+52.0           33.0           14.0           34.0           44.0
+35.0           45.0           55.0

data/spec/io_spec.rb

@@ -0,0 +1,149 @@
+# = 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
+#
+# == io_spec.rb
+#
+# Basic tests for NMatrix::IO.
+#
+require "tmpdir" # Used to avoid cluttering the repository.
+require 'spec_helper'
+require "./lib/nmatrix"
+
+describe NMatrix::IO do
+  let(:tmp_dir)  { Dir.mktmpdir }
+  let(:test_out) { File.join(tmp_dir, 'test-out') }
+
+  it "repacks a string" do
+    expect(NMatrix::IO::Matlab.repack("hello", :miUINT8, :byte)).to eq("hello")
+  end
+
+  it "creates yale from internal byte-string function" do
+    ia = NMatrix::IO::Matlab.repack("\0\1\3\3\4", :miUINT8, :itype)
+    ja = NMatrix::IO::Matlab.repack("\0\1\3\0\0\0\0\0\0\0\0", :miUINT8, :itype)
+    n = NMatrix.new(:yale, [4,4], :byte, ia, ja, "\2\3\5\4", :byte)
+    expect(n[0,0]).to eq(2)
+    expect(n[1,1]).to eq(3)
+    expect(n[1,3]).to eq(5)
+    expect(n[3,0]).to eq(4)
+    expect(n[2,2]).to eq(0)
+    expect(n[3,3]).to eq(0)
+  end
+
+  it "reads MATLAB .mat file containing a single square sparse matrix" do
+    # Note: same matrix as above
+    n = NMatrix::IO::Matlab.load_mat("spec/4x4_sparse.mat")
+    expect(n[0,0]).to eq(2)
+    expect(n[1,1]).to eq(3)
+    expect(n[1,3]).to eq(5)
+    expect(n[3,0]).to eq(4)
+    expect(n[2,2]).to eq(0)
+    expect(n[3,3]).to eq(0)
+  end
+
+  it "reads MATLAB .mat file containing a single dense integer matrix" do
+    n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
+    m = NMatrix.new([4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
+    expect(n).to eq(m)
+  end
+
+  it "reads MATLAB .mat file containing a single dense double matrix" do
+    n = NMatrix::IO::Matlab.load_mat("spec/2x2_dense_double.mat")
+    m = NMatrix.new(2, [1.1, 2.0, 3.0, 4.0], dtype: :float64)
+    expect(n).to eq(m)
+  end
+
+  it "loads and saves MatrixMarket .mtx file containing a single large sparse double matrix" do
+    pending "spec disabled because it's so slow"
+    n = NMatrix::IO::Market.load("spec/utm5940.mtx")
+    NMatrix::IO::Market.save(n, "spec/utm5940.saved.mtx")
+    expect(`wc -l spec/utm5940.mtx`.split[0]).to eq(`wc -l spec/utm5940.saved.mtx`.split[0])
+  end
+
+  it "loads a Point Cloud Library PCD file" do
+    n = NMatrix::IO::PointCloud.load("spec/test.pcd")
+    expect(n.column(0).sort.uniq.size).to eq(1)
+    expect(n.column(0).sort.uniq.first).to eq(207.008)
+    expect(n[0,3]).to eq(0)
+  end
+
+  it "raises an error when reading a non-existent file" do
+    fn = rand(10000000).to_i.to_s
+    while File.exist?(fn)
+      fn = rand(10000000).to_i.to_s
+    end
+    expect{ NMatrix.read(fn) }.to raise_error(Errno::ENOENT)
+  end
+
+  it "reads and writes NMatrix dense" do
+    n = NMatrix.new(:dense, [4,3], [0,1,2,3,4,5,6,7,8,9,10,11], :int32)
+    n.write(test_out)
+
+    m = NMatrix.read(test_out)
+    expect(n).to eq(m)
+  end
+
+  it "reads and writes NMatrix dense as symmetric" do
+    n = NMatrix.new(:dense, 3, [0,1,2,1,3,4,2,4,5], :int16)
+    n.write(test_out, :symmetric)
+
+    m = NMatrix.read(test_out)
+    expect(n).to eq(m)
+  end
+
+  it "reads and writes NMatrix dense as skew" do
+    n = NMatrix.new(:dense, 3, [0,1,2,-1,3,4,-2,-4,5], :float64)
+    n.write(test_out, :skew)
+
+    m = NMatrix.read(test_out)
+    expect(n).to eq(m)
+  end
+
+  it "reads and writes NMatrix dense as hermitian" do
+    n = NMatrix.new(:dense, 3, [0,1,2,1,3,4,2,4,5], :complex64)
+    n.write(test_out, :hermitian)
+
+    m = NMatrix.read(test_out)
+    expect(n).to eq(m)
+  end
+
+  it "reads and writes NMatrix dense as upper" do
+    n = NMatrix.new(:dense, 3, [-1,1,2,3,4,5,6,7,8], :int32)
+    n.write(test_out, :upper)
+
+    m = NMatrix.new(:dense, 3, [-1,1,2,0,4,5,0,0,8], :int32) # lower version of the same
+
+    o = NMatrix.read(test_out)
+    expect(o).to eq(m)
+    expect(o).not_to eq(n)
+  end
+
+  it "reads and writes NMatrix dense as lower" do
+    n = NMatrix.new(:dense, 3, [-1,1,2,3,4,5,6,7,8], :int32)
+    n.write(test_out, :lower)
+
+    m = NMatrix.new(:dense, 3, [-1,0,0,3,4,0,6,7,8], :int32) # lower version of the same
+
+    o = NMatrix.read(test_out)
+    expect(o).to eq(m)
+    expect(o).not_to eq(n)
+  end
+end