pnmatrix 1.2.4

data/spec/spec_helper.rb

@@ -0,0 +1,172 @@
+# = 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
+#
+# == spec_helper.rb
+#
+# Common data and helper functions for testing.
+
+require "rspec/longrun"
+#require "narray/narray"
+
+require "./lib/nmatrix"
+require "./lib/nmatrix/rspec"
+
+ALL_DTYPES = [:byte,:int8,:int16,:int32,:int64, :float32,:float64, :object,
+  :complex64, :complex128]
+  
+NON_INTEGER_DTYPES = [:float32, :float64, :complex64, :complex128,
+  :object]
+
+FLOAT_DTYPES = [:float32, :float64]
+  
+MATRIX43A_ARRAY = [14.0, 9.0, 3.0, 2.0, 11.0, 15.0, 0.0, 12.0, 17.0, 5.0, 2.0, 3.0]
+MATRIX32A_ARRAY = [12.0, 25.0, 9.0, 10.0, 8.0, 5.0]
+
+COMPLEX_MATRIX43A_ARRAY = MATRIX43A_ARRAY.zip(MATRIX43A_ARRAY.reverse).collect { |ary| Complex(ary[0], ary[1]) }
+COMPLEX_MATRIX32A_ARRAY = MATRIX32A_ARRAY.zip(MATRIX32A_ARRAY.reverse).collect { |ary| Complex(ary[0], -ary[1]) }
+
+#3x4 matrix used for testing various getrf and LU decomposition functions
+GETRF_EXAMPLE_ARRAY = [-1,0,10,4,9,2,3,5,7,8,1,6]
+GETRF_SOLUTION_ARRAY = [9.0, 2.0, 3.0, 5.0, 7.0/9, 58.0/9, -4.0/3, 19.0/9, -1.0/9, 1.0/29, 301.0/29, 130.0/29]
+
+TAU_SOLUTION_ARRAY = [1.8571428571428572,1.9938461538461538, 0.0]
+
+GEQRF_SOLUTION_ARRAY =[                -14.0,                -21.0, 14.000000000000002,
+                         0.23076923076923078,  -175.00000000000003,  70.00000000000001,
+                        -0.15384615384615385, 0.055555555555555546,              -35.0]
+
+R_SOLUTION_ARRAY   = [-159.2388143638353, -41.00131005172065, -56.75123892439876,  -90.75048729628048, 
+                                     0.0, 25.137473501580676,  2.073591725046292,   9.790607357775713, 
+                                     0.0,                0.0, -20.83259700334131, -17.592414929551445]
+
+Q_SOLUTION_ARRAY_1 = [-0.632455532033676, -0.5209522876558295, -0.3984263084135902,  -0.41214704991068,
+                    -0.42783756578748666, -0.20837937347171134, 0.876505919951498, 0.07259770177184455,
+                    -0.48364246567281094, 0.8265854747306287,-0.015758658987033422, -0.2873988222474053,
+                    -0.42783756578748666,  0.044081783789183565, -0.26971376257215296, 0.8615487797670971]
+
+Q_SOLUTION_ARRAY_2 = [-0.8571428571428572,   0.3942857142857143,  0.33142857142857146, 
+                      -0.4285714285714286,  -0.9028571428571428, -0.03428571428571425, 
+                       0.28571428571428575, -0.1714285714285714,   0.9428571428571428]
+
+Q_SOLUTION_ARRAY_3 = [-0.7724247413634004, -0.026670393594597247, -0.6345460653374136, 
+                      -0.5777485870360393,  -0.38541856437557026,  0.7194853024298236,
+                      -0.26375478973384403,   0.9223563413020934, 0.28229805268947933]
+
+def create_matrix(stype) #:nodoc:
+  m = NMatrix.new([3,3], 0, dtype: :int32, stype: stype, default: 0)
+
+  m[0,0] = 0
+  m[0,1] = 1
+  m[0,2] = 2
+  m[1,0] = 3
+  m[1,1] = 4
+  m[1,2] = 5
+  m[2,0] = 6
+  m[2,1] = 7
+  m[2,2] = 8
+
+  m
+end
+
+def create_rectangular_matrix(stype) #:nodoc:
+  m = NMatrix.new([5,6], 0, dtype: :int32, stype: stype, default: 0)
+
+  m[0,0] = 1
+  m[0,1] = 2
+  m[0,2] = 3
+  m[0,3] = 4
+  m[0,4] = 5
+  m[0,5] = 0
+
+  m[1,0] = 6
+  m[1,1] = 7
+  m[1,2] = 8
+  m[1,3] = 9
+  m[1,4] = 0
+  m[1,5] = 10
+
+  m[2,0] = 11
+  m[2,1] = 12
+  m[2,2] = 13
+  m[2,3] = 0
+  m[2,4] = 14
+  m[2,5] = 15
+
+  # skip row 3 -- all 0
+  m[3,0] = m[3,1] = m[3,2] = m[3,3] = m[3,4] = m[3,5] = 0
+
+  m[4,0] = 16
+  m[4,1] = 0
+  m[4,2] = 17
+  m[4,3] = 18
+  m[4,4] = 19
+  m[4,5] = 20
+
+  m
+end
+
+def create_vector(stype) #:nodoc:
+  m = stype == :yale ? NVector.new(stype, 10, :int32) : NVector.new(stype, 10, 0, :int32)
+
+  m[0] = 1
+  m[1] = 2
+  m[2] = 3
+  m[3] = 4
+  m[4] = 5
+  m[5] = 6
+  m[6] = 7
+  m[7] = 8
+  m[8] = 9
+  m[9] = 10
+
+  m
+end
+
+# Stupid but independent comparison for slice_spec
+def nm_eql(n, m) #:nodoc:
+  if n.shape != m.shape
+    false
+  else # NMatrix
+    n.shape[0].times do |i|
+      n.shape[1].times do |j|
+        if n[i,j] != m[i,j]
+          puts "n[#{i},#{j}] != m[#{i},#{j}] (#{n[i,j]} != #{m[i,j]})"
+          return false
+        end
+      end
+    end
+  end
+  true
+end
+
+def integer_dtype? dtype
+  [:byte,:int8,:int16,:int32,:int64].include?(dtype)
+end
+
+# If a focus: true option is supplied to any test, running `rake spec focus=true`
+# will run only the focused tests and nothing else.
+if ENV["focus"] == "true"
+  RSpec.configure do |c|
+    c.filter_run :focus => true
+  end
+end
+

data/spec/stat_spec.rb

@@ -0,0 +1,214 @@
+# = 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
+#
+# == stat_spec.rb
+#
+# Tests for statistical functions in NMatrix.
+#
+
+require 'spec_helper'
+require 'pry'
+
+describe "Statistical functions" do
+  context "mapping and reduction related functions" do
+    [:dense, :yale, :list].each do |stype|
+      context "on #{stype} matrices" do
+        let(:nm_1d) { NMatrix.new([5], [5.0,0.0,1.0,2.0,3.0], stype: stype) unless stype == :yale }
+        let(:nm_2d) { NMatrix.new([2,2], [0.0, 1.0, 2.0, 3.0], stype: stype) }
+
+        it "behaves like Enumerable#reduce with no argument to reduce" do
+          expect(nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f).to eq 11 unless stype == :yale
+          expect(nm_2d.reduce_along_dim(1) { |acc, el| acc + el }).to eq NMatrix.new([2,1], [1.0, 5.0], stype: stype)
+        end
+
+        it "should calculate the mean along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          unless stype == :yale then
+            puts nm_1d.mean
+            expect(nm_1d.mean).to eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
+          end
+          expect(nm_2d.mean).to eq NMatrix[[1.0,2.0], stype: stype]
+          expect(nm_2d.mean(1)).to eq NMatrix[[0.5], [2.5], stype: stype]
+        end
+
+        it "should calculate the minimum along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          expect(nm_1d.min).to eq 0.0 unless stype == :yale
+          expect(nm_2d.min).to eq NMatrix[[0.0, 1.0], stype: stype]
+          expect(nm_2d.min(1)).to eq NMatrix[[0.0], [2.0], stype: stype]
+        end
+
+        it "should calculate the maximum along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          expect(nm_1d.max).to eq 5.0  unless stype == :yale
+          expect(nm_2d.max).to eq NMatrix[[2.0, 3.0], stype: stype]
+        end
+
+        it "should calculate the variance along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          expect(nm_1d.variance).to eq NMatrix[3.7, stype: stype] unless stype == :yale
+          expect(nm_2d.variance(1)).to eq NMatrix[[0.5], [0.5], stype: stype]
+        end
+
+        it "should calculate the sum along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          expect(nm_1d.sum).to eq NMatrix[11.0, stype: stype] unless stype == :yale
+          expect(nm_2d.sum).to eq NMatrix[[2.0, 4.0], stype: stype]
+        end
+
+        it "should calculate the standard deviation along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          expect(nm_1d.std).to eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
+          expect(nm_2d.std(1)).to 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
+          expect(NMatrix[4.0, stype: stype].to_f).to eq 4.0  unless stype == :yale
+          expect(NMatrix[[[[4.0]]], stype: stype].to_f).to eq 4.0  unless stype == :yale
+          expect(NMatrix[[4.0], stype: stype].to_f).to 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
+          expect(nm_1d.map { |e| e ** 2 }).to eq NMatrix[25.0,0.0,1.0,4.0,9.0, stype: stype] unless stype == :yale
+          expect(nm_2d.map { |e| e ** 2 }).to 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)
+            expect(nm_1d).to eq expected1
+          end
+          expected2 = nm_2d.map(&fct)
+          nm_2d.map!(&fct)
+          expect(nm_2d).to eq expected2
+        end
+
+        it "should return an enumerator for map without a block" do
+          expect(nm_2d.map).to be_a Enumerator
+        end
+
+        it "should return an enumerator for reduce without a block" do
+          expect(nm_2d.reduce_along_dim(0)).to be_a Enumerator
+        end
+
+        it "should return an enumerator for each_along_dim without a block" do
+          expect(nm_2d.each_along_dim(0)).to be_a Enumerator
+        end
+
+        it "should iterate correctly for map without a block" do
+          en = nm_1d.map unless stype == :yale
+          expect(en.each { |e| e**2 }).to eq nm_1d.map { |e| e**2 } unless stype == :yale
+          en = nm_2d.map
+          expect(en.each { |e| e**2 }).to eq nm_2d.map { |e| e**2 }
+        end
+
+        it "should iterate correctly for reduce without a block" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          unless stype == :yale then
+            en = nm_1d.reduce_along_dim(0, 1.0)
+            expect(en.each { |a, e| a+e }.to_f).to eq 12
+          end
+          en = nm_2d.reduce_along_dim(1, 1.0)
+          expect(en.each { |a, e| a+e }).to 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 }
+            expect(res.to_f).to eq 11
+          end
+          res = NMatrix.zeros_like (nm_2d[0...2, 0])
+          en = nm_2d.each_along_dim(1)
+          en.each { |e| res += e }
+          expect(res).to 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|
+            expect(sub_m.dtype).to 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|
+            expect(sub_m.dtype).to eq :complex128
+            acc
+          end
+
+          m.reduce_along_dim(1, 0.0) do |acc, sub_m|
+            expect(sub_m.dtype).to eq :complex128
+            acc
+          end
+        end
+
+        it "should allow overriding the dtype for reduce_along_dim" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128]
+          m.reduce_along_dim(1, 0.0, :float64) do |acc, sub_m|
+            expect(acc.dtype).to 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|
+            expect(acc.dtype).to eq :float64
+            acc
+          end
+        end
+
+        it "should convert integer dtypes to float when calculating mean" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
+          expect(m.mean(0).dtype).to eq :float64
+        end
+
+        it "should convert integer dtypes to float when calculating variance" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
+          expect(m.variance(0).dtype).to eq :float64
+        end
+
+        it "should convert integer dtypes to float when calculating standard deviation" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
+          m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
+          expect(m.std(0).dtype).to eq :float64
+        end
+      end
+    end
+  end
+end

data/spec/test.pcd

@@ -0,0 +1,20 @@
+VERSION .7
+FIELDS x y z intensity
+SIZE 4 8 8 4
+TYPE F U F I
+COUNT 1 1 1 1
+WIDTH 256 # comment here to challenge this thing
+HEIGHT 256
+VIEWPOINT 0 0 0 1 0 0 0
+POINTS 10
+DATA ASCII
+207.008 207.058 1174 0
+207.008 205.441 1174 0
+207.008 203.823 1174 0
+207.008 202.206 1174 0
+207.008 200.589 1174 0
+207.008 198.972 1174 0
+207.008 197.354 1174 0
+207.008 195.737 1174 0
+207.008 194.12 1174 0
+207.008 153.689 1174 0