nmatrix 0.2.3 → 0.2.4

data/spec/rspec_spec.rb

@@ -28,6 +28,7 @@ require 'spec_helper'
 
 describe "RSpec" do
   it "should permit #be_within to be used on a dense NMatrix" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     expect(NMatrix.new([4,1], 1.0, dtype: :complex128, stype: :dense) / 10000.0).to be_within(0.00000001).of(NMatrix.new([4,1], 0.0001, dtype: :float64, stype: :dense))
     expect(NMatrix.new([4,1], 1.0, dtype: :complex128, stype: :dense) / 10000.0).not_to be_within(0.00000001).of(NMatrix.new([4,1], 1.0, dtype: :float64, stype: :dense))
   end

data/spec/shortcuts_spec.rb

@@ -104,13 +104,14 @@ describe NMatrix do
     [:dense, :yale, :list].each do |stype|
       context "#block_diagonal #{dtype} #{stype}" do
         it "block_diagonal() creates a block-diagonal NMatrix" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby? and dtype == :object
           a = NMatrix.new([2,2], [1,2,
                                   3,4])
           b = NMatrix.new([1,1], [123.0])
           c = NMatrix.new([3,3], [1,2,3,
                                   1,2,3,
                                   1,2,3])
-          d = Array[ [1,1,1], [2,2,2], [3,3,3] ] 
+          d = Array[ [1,1,1], [2,2,2], [3,3,3] ]
           e = 12
           m = NMatrix.block_diagonal(a, b, c, d, e, dtype: dtype, stype: stype)
           expect(m).to eq(NMatrix.new([10,10], [1, 2,   0, 0, 0, 0, 0, 0, 0,  0,
@@ -136,6 +137,17 @@ describe NMatrix do
       expect(m.dtype).to eq(:float64)
     end
 
+    it "creates a matrix of random numbers with defined seed value" do
+      m1 = NMatrix.random(2,:seed => 62)
+      m2 = NMatrix.random(2,:seed => 62)
+      m3 = NMatrix.random(2,:seed => 65)
+
+
+      expect(m1).to eq(m2)
+      expect(m1).not_to eq(m3)
+
+    end
+
     it "creates a complex matrix of random numbers" do
       m = NMatrix.random(2, :dtype => :complex128)
     end
@@ -158,42 +170,44 @@ describe NMatrix do
       expect { NMatrix.random("not an array or integer") }.to raise_error
     end
   end
-  
+
   context "::magic" do
-    
+
     ALL_DTYPES.each do |dtype|
       context dtype do
         it "creates a matrix with numbers from 1 to n^n(n squared)" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           a = NMatrix.magic(3, dtype: dtype)
-          magic3 = NMatrix.new([3,3], [4, 9, 2, 3, 5, 7, 8, 1, 6], dtype: dtype)	
+          magic3 = NMatrix.new([3,3], [4, 9, 2, 3, 5, 7, 8, 1, 6], dtype: dtype)
           expect(a).to eq magic3
-      
+
           b = NMatrix.magic(4, dtype: dtype)
           magic4 = NMatrix.new([4,4], [1, 15, 14,  4, 12,  6,  7, 9, 8, 10, 11, 5, 13, 3, 2, 16], dtype: dtype)
           expect(b).to eq magic4
-      
+
           c = NMatrix.magic(6, dtype: dtype)
           magic6 = NMatrix.new([6,6], [31, 9, 2, 22, 27, 20, 3, 32, 7, 21, 23, 25, 35, 1, 6, 26, 19, 24, 4, 36, 29, 13, 18, 11, 30, 5, 34, 12, 14, 16, 8, 28, 33, 17, 10, 15], dtype: dtype)
-          expect(c).to eq magic6  
+          expect(c).to eq magic6
         end
       end
     end
-    
+
     it "shape of two is not allowed" do
       expect { NMatrix.magic(2) }.to raise_error(ArgumentError)
     end
-    
-    it "Only accepts an integer as dimension" do 
+
+    it "Only accepts an integer as dimension" do
       expect { NMatrix.magic(3.0) }.to raise_error(ArgumentError)
     end
   end
-  
+
   context "::linspace" do
     it "creates a row vector when given only one shape parameter" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.linspace(1, 10, 4)
       #Expect a row vector only
       expect(v.shape.length).to eq(1)
-      
+
       ans = [1.0,4.0,7.0,10.0]
 
       expect(v[0]).to be_within(0.000001).of(ans[0])
@@ -201,13 +215,14 @@ describe NMatrix do
       expect(v[2]).to be_within(0.000001).of(ans[2])
       expect(v[3]).to be_within(0.000001).of(ans[3])
     end
-    
+
     it "creates a matrix of input shape with each entry linearly spaced in row major order" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.linspace(1, Math::PI, [2,2])
       expect(v.dtype).to eq(:float64)
 
       ans = [1.0, 1.7138642072677612, 2.4277284145355225, 3.1415927410125732]
-      
+
       expect(v[0,0]).to be_within(0.000001).of(ans[0])
       expect(v[0,1]).to be_within(0.000001).of(ans[1])
       expect(v[1,0]).to be_within(0.000001).of(ans[2])
@@ -217,13 +232,14 @@ describe NMatrix do
 
   context "::logspace" do
     it "creates a logarithmically spaced vector" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.logspace(1, 2, 10)
-      
+
       expect(v.shape.length).to eq(1)
-      
+
       #Unit test taken from Matlab R2015b output of logspace(1,2,10)
       ans = [10.0000, 12.9155, 16.6810, 21.5443, 27.8256, 35.9381, 46.4159, 59.9484, 77.4264, 100.0000]
-      
+
       expect(v[0].round(4)).to be_within(0.000001).of(ans[0])
       expect(v[1].round(4)).to be_within(0.000001).of(ans[1])
       expect(v[2].round(4)).to be_within(0.000001).of(ans[2])
@@ -235,13 +251,14 @@ describe NMatrix do
       expect(v[8].round(4)).to be_within(0.000001).of(ans[8])
       expect(v[9].round(4)).to be_within(0.000001).of(ans[9])
     end
-    
+
     it "creates a logarithmically spaced vector bounded by Math::PI if :pi is pre-supplied" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.logspace(1, :pi, 7)
-                 
+
       #Unit test taken from Matlab R2015b output of logspace(1,pi,10)
       ans = [10.0000, 8.2450, 6.7980, 5.6050, 4.6213, 3.8103, 3.1416]
-      
+
       expect(v[0].round(4)).to be_within(0.000001).of(ans[0])
       expect(v[1].round(4)).to be_within(0.000001).of(ans[1])
       expect(v[2].round(4)).to be_within(0.000001).of(ans[2])
@@ -249,13 +266,14 @@ describe NMatrix do
       expect(v[4].round(4)).to be_within(0.000001).of(ans[4])
       expect(v[5].round(4)).to be_within(0.000001).of(ans[5])
       expect(v[6].round(4)).to be_within(0.000001).of(ans[6])
-    end    
+    end
 
     it "creates a matrix of input shape with each entry logarithmically spaced in row major order" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.logspace(1, 2, [3,2])
-      
+
       ans = [10.0, 15.8489, 25.1189, 39.8107, 63.0957, 100.0]
-      
+
       expect(v[0,0].round(4)).to be_within(0.000001).of(ans[0])
       expect(v[0,1].round(4)).to be_within(0.000001).of(ans[1])
       expect(v[1,0].round(4)).to be_within(0.000001).of(ans[2])
@@ -360,6 +378,7 @@ describe NMatrix do
     end
 
     it "should create an nmatrix of ones with dimensions and type the same as its argument" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       expect(NMatrix.ones_like(@nm_1d)).to eq NMatrix[1.0, 1.0, 1.0, 1.0, 1.0]
       expect(NMatrix.ones_like(@nm_2d)).to eq NMatrix[[1.0, 1.0], [1.0, 1.0]]
     end
@@ -383,6 +402,7 @@ describe "NVector" do
   end
 
   it "ones() creates a vector of ones" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.ones(3)
 
     3.times do |i|
@@ -391,6 +411,7 @@ describe "NVector" do
   end
 
   it "random() creates a vector of random numbers" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.random(4)
     expect(v.dtype).to eq(:float64)
     expect(v.stype).to eq(:dense)
@@ -424,16 +445,19 @@ describe "NVector" do
   end
 
   it "cindgen() creates a vector of complexes, sequentially" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.cindgen(2)
     expect(v).to eq(NMatrix.new([2,1], [Complex(0.0, 0.0), Complex(1.0, 0.0)], dtype: :complex64))
   end
 
   it "linspace() creates a vector with n values equally spaced between a and b" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.linspace(0, 2, 5)
     expect(v).to eq(NMatrix.new([5,1], [0.0, 0.5, 1.0, 1.5, 2.0]))
   end
 
   it "logspace() creates a vector with n values logarithmically spaced between decades 10^a and 10^b" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.logspace(0, 3, 4)
     expect(v).to eq(NMatrix.new([4,1], [1.0, 10.0, 100.0, 1000.0]))
   end

data/spec/slice_set_spec.rb

@@ -40,8 +40,12 @@ describe "Set slice operation" do
 
         if stype == :yale
           step "verify correct arrangement of Yale IJA and A arrays" do
-            @m.extend NMatrix::YaleFunctions
-            expect(@m.yale_ija).to eq([4,6,8,10,1,2,0,2,0,1])
+            @m.extend NMatrix::YaleFunctions unless jruby?
+            if jruby?
+              pending("not yet implemented for NMatrix-JRuby")
+            else
+              expect(@m.yale_ija).to eq([4,6,8,10,1,2,0,2,0,1])
+            end
             expect(@m.yale_a).to   eq([0,4,8,0, 1,2,3,5,6,7])
           end
         end
@@ -145,6 +149,7 @@ describe "Set slice operation" do
       end
 
       example "set a range of values to a matrix's contents" do
+        pending("not yet implemented for int dtype for NMatrix-JRuby") if jruby?
         x = NMatrix.new(4, stype: :yale, dtype: :int16)
         x.extend NMatrix::YaleFunctions if stype == :yale
         x[1..3,1..3] = @m

data/spec/stat_spec.rb

@@ -41,6 +41,7 @@ describe "Statistical functions" do
         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)
@@ -50,27 +51,32 @@ describe "Statistical functions" do
         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
@@ -128,6 +134,7 @@ describe "Statistical functions" do
         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
@@ -170,6 +177,7 @@ describe "Statistical functions" do
         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
@@ -184,16 +192,19 @@ describe "Statistical functions" do
         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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nmatrix
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - John Woods
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-25 00:00:00.000000000 Z
+date: 2017-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: packable
@@ -46,20 +46,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.0.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -209,7 +195,6 @@ files:
 - ext/nmatrix/storage/yale/math/transpose.h
 - ext/nmatrix/storage/yale/yale.cpp
 - ext/nmatrix/storage/yale/yale.h
-- ext/nmatrix/ttable_helper.rb
 - ext/nmatrix/types.h
 - ext/nmatrix/util/io.cpp
 - ext/nmatrix/util/io.h
@@ -218,6 +203,7 @@ files:
 - ext/nmatrix/util/util.h
 - lib/nmatrix.rb
 - lib/nmatrix/blas.rb
+- lib/nmatrix/cruby/math.rb
 - lib/nmatrix/enumerate.rb
 - lib/nmatrix/homogeneous.rb
 - lib/nmatrix/io/fortran_format.rb
@@ -226,6 +212,13 @@ files:
 - lib/nmatrix/io/mat5_reader.rb
 - lib/nmatrix/io/mat_reader.rb
 - lib/nmatrix/io/point_cloud.rb
+- lib/nmatrix/jruby/decomposition.rb
+- lib/nmatrix/jruby/enumerable.rb
+- lib/nmatrix/jruby/error.rb
+- lib/nmatrix/jruby/math.rb
+- lib/nmatrix/jruby/nmatrix_java.rb
+- lib/nmatrix/jruby/operators.rb
+- lib/nmatrix/jruby/slice.rb
 - lib/nmatrix/lapack_core.rb
 - lib/nmatrix/lapack_plugin.rb
 - lib/nmatrix/math.rb
@@ -267,29 +260,15 @@ homepage: http://sciruby.com
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message: |
-  ***********************************************************
-  Welcome to SciRuby: Tools for Scientific Computing in Ruby!
-
-  NMatrix requires a C compiler, and has been tested only
-  with GCC 4.6+. We are happy to accept contributions
-  which improve the portability of this project.
-
-  If you are upgrading from NMatrix 0.1.0 and rely on
-  ATLAS features, please check the README.
-
-  Faster matrix calculations and more advanced linear
-  algebra features are available by installing either
-  the nmatrix-atlas or nmatrix-lapacke plugins.
-
-  More explicit instructions for NMatrix and SciRuby should
-  be available on the SciRuby website, sciruby.com, or
-  through our mailing list (which can be found on our web-
-  site).
-
-  Thanks for trying out NMatrix! Happy coding!
-
-  ***********************************************************
+post_install_message: "***********************************************************\nWelcome
+  to SciRuby: Tools for Scientific Computing in Ruby!\n\nNMatrix requires a C/C++
+  compiler. Clang and GCC are \nrecommended. JRuby support is experimental, and requires\nJava.\n\nIf
+  you are upgrading from NMatrix 0.1.0 and rely on\nATLAS features, please check the
+  README.\n\nFaster matrix calculations and more advanced linear\nalgebra features
+  are available by installing either\nthe nmatrix-atlas or nmatrix-lapacke plugins.\n\nMore
+  explicit instructions for NMatrix and SciRuby should\nbe available on the SciRuby
+  website, sciruby.com, or\nthrough our mailing list (which can be found on our web-\nsite).\n\nThanks
+  for trying out NMatrix! Happy coding!\n\n***********************************************************\n"
 rdoc_options: []
 require_paths:
 - lib
@@ -305,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: NMatrix is a linear algebra library for Ruby

data/ext/nmatrix/ttable_helper.rb

@@ -1,115 +0,0 @@
-#!/usr/bin/ruby
-
-# A helper file for generating and maintaining template tables.
-
-DTYPES = [
-          :uint8_t,
-          :int8_t,
-          :int16_t,
-          :int32_t,
-          :int64_t,
-          :float32_t,
-          :float64_t,
-          :'nm::Complex64',
-          :'nm::Complex128',
-          :'nm::RubyObject'
-         ]
-
-def nullify(disabled = []) #:nodoc:
-  DTYPES.map { |t| if disabled.include?(t) then :NULL else t end }
-end
-
-ITYPES = [
-          :uint8_t,
-          :uint16_t,
-          :uint32_t,
-          :uint64_t
-         ]
-
-EWOPS = [
-         :'nm::EW_ADD',
-         :'nm::EW_SUB',
-         :'nm::EW_MUL',
-         :'nm::EW_DIV',
-         :'nm::EW_POW',
-         :'nm::EW_MOD',
-         :'nm::EW_EQEQ',
-         :'nm::EW_NEQ',
-         :'nm::EW_LT',
-         :'nm::EW_GT',
-         :'nm::EW_LEQ',
-         :'nm::EW_GEQ'
-        ]
-
-LR_ALLOWED = {
-  :uint8_t       => DTYPES,
-  :int8_t        => DTYPES,
-  :int16_t      => DTYPES,
-  :int32_t      => DTYPES,
-  :int64_t      => DTYPES,
-  :float32_t    => DTYPES,
-  :float64_t    => DTYPES,
-  :'nm::Complex64'    => DTYPES,
-  :'nm::Complex128'    => DTYPES,
-  :'nm::RubyObject'    => DTYPES
-}
-
-lines =
-  case ARGV[0]
-  when 'OPLR'
-    '{' +
-      EWOPS.map do |op|
-
-    '{' +
-      DTYPES.map do |l_dtype|
-
-      '{' +
-        LR_ALLOWED[l_dtype].map do |r_dtype|
-        if r_dtype == :NULL
-          'NULL'
-        else
-          "fun<#{op}, #{l_dtype}, #{r_dtype}>"
-        end
-      end.join(', ') +
-        '}'
-
-    end.join(",\n") +
-      '}'
-
-  end.join(",\n") +
-      '}'
-
-  when 'OPID'
-    '{' +
-      EWOPS.map do |op|
-    '{' +
-      ITYPES.map do |itype|
-      '{' +
-        DTYPES.map do |dtype|
-
-        if dtype == :NULL
-          'NULL'
-        else
-          "fun<#{op}, #{itype}, #{dtype}>"
-        end
-
-      end.join(",") +
-        '}'
-    end.join(",\\\n") +
-      '}'
-  end.join(",\\\n") +
-      '}'
-
-  when 'LR'
-    '{' + DTYPES.map do |l_dtype|
-      '{' + LR_ALLOWED[l_dtype].map do |r_dtype|
-        if r_dtype == :NULL
-          'NULL'
-        else
-          "fun<#{l_dtype}, #{r_dtype}>"
-        end
-      end.join(', ') + '}'
-    end.join(",\n") + '}'
-  end
-
-puts lines