nmatrix-atlas 0.2.0

data/spec/rspec_monkeys.rb

@@ -0,0 +1,56 @@
+# = 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
+#
+# == rspec_monkeys.rb
+#
+# A set of monkey patches for RSpec allowing checks of NMatrix types
+#
+
+module RSpec::Matchers::BuiltIn
+  class BeWithin
+
+    def of(expected)
+      @expected = expected
+      @unit     = ''
+      if expected.is_a?(NMatrix)
+        @tolerance = if @delta.is_a?(NMatrix)
+                       @delta.clone
+                     elsif @delta.is_a?(Array)
+                       NMatrix.new(:dense, expected.shape, @delta, expected.dtype)
+                     else
+                       NMatrix.ones_like(expected) * @delta
+                     end
+      else
+        @tolerance = @delta
+      end
+
+      self
+    end
+
+    def percent_of(expected)
+      @expected  = expected
+      @unit      = '%'
+      @tolerance = @expected.abs * @delta / 100.0 # <- only change is to reverse abs and @delta
+      self
+    end
+  end
+end

data/spec/rspec_spec.rb

@@ -0,0 +1,34 @@
+# = 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
+#
+# == rspec_spec.rb
+#
+# A spec for testing monkey patches to RSpec for NMatrix.
+#
+require 'spec_helper'
+
+describe "RSpec" do
+  it "should permit #be_within to be used on a dense NMatrix" do
+    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
+end

data/spec/shortcuts_spec.rb

@@ -0,0 +1,310 @@
+# = 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
+#
+# == shortcuts_spec.rb
+#
+# Specs for the shortcuts used in NMatrix and in NVector.
+#
+
+require 'spec_helper'
+require 'pry'
+
+describe NMatrix do
+  it "zeros() creates a matrix of zeros" do
+    m = NMatrix.zeros(3)
+    n = NMatrix.new([3, 3], 0)
+
+    expect(m).to eq n
+  end
+
+  it "ones() creates a matrix of ones" do
+    m = NMatrix.ones(3)
+    n = NMatrix.new([3, 3], 1)
+
+    expect(m).to eq n
+  end
+
+  it "eye() creates an identity matrix" do
+    m = NMatrix.eye(3)
+    identity3 = NMatrix.new([3, 3], [1, 0, 0, 0, 1, 0, 0, 0, 1])
+
+    expect(m).to eq identity3
+  end
+
+  it "diag() creates a matrix with pre-supplied diagonal" do
+    arr = [1,2,3,4]
+    m = NMatrix.diag(arr)
+    expect(m.is_a?(NMatrix)).to be_true
+  end
+
+  it "diagonals() contains the seeded values on the diagonal" do
+    arr = [1,2,3,4]
+    m = NMatrix.diagonals(arr)
+    expect(m[0,0]).to eq(arr[0])
+    expect(m[1,1]).to eq(arr[1])
+    expect(m[2,2]).to eq(arr[2])
+    expect(m[3,3]).to eq(arr[3])
+  end
+
+  ALL_DTYPES.each do |dtype|
+    [:dense, :yale, :list].each do |stype|
+      context "#block_diagonal #{dtype} #{stype}" do
+        it "block_diagonal() creates a block-diagonal NMatrix" do
+          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] ] 
+          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,
+                                                3, 4,   0, 0, 0, 0, 0, 0, 0,  0,
+                                                0, 0, 123, 0, 0, 0, 0, 0, 0,  0,
+                                                0, 0,   0, 1, 2, 3, 0, 0, 0,  0,
+                                                0, 0,   0, 1, 2, 3, 0, 0, 0,  0,
+                                                0, 0,   0, 1, 2, 3, 0, 0, 0,  0,
+                                                0, 0,   0, 0, 0, 0, 1, 1, 1,  0,
+                                                0, 0,   0, 0, 0, 0, 2, 2, 2,  0,
+                                                0, 0,   0, 0, 0, 0, 3, 3, 3,  0,
+                                                0, 0,   0, 0, 0, 0, 0, 0, 0, 12], dtype: dtype, stype: stype))
+        end
+      end
+    end
+  end
+
+  context "::random" do
+    it "creates a matrix of random numbers" do
+      m = NMatrix.random(2)
+
+      expect(m.stype).to eq(:dense)
+      expect(m.dtype).to eq(:float64)
+    end
+
+    it "creates a complex matrix of random numbers" do
+      m = NMatrix.random(2, :dtype => :complex128)
+    end
+
+    it "correctly accepts :scale parameter" do
+      m = NMatrix.random([2,2], dtype: :byte, scale: 255)
+      m.each do |v|
+        expect(v).to be >= 0
+        expect(v).to be < 255
+      end
+    end
+
+    it "only accepts an integer or an array as dimension" do
+      m = NMatrix.random([2, 2])
+
+      expect(m.stype).to eq(:dense)
+      expect(m.dtype).to eq(:float64)
+
+      expect { NMatrix.random(2.0) }.to raise_error
+      expect { NMatrix.random("not an array or integer") }.to raise_error
+    end
+  end
+
+  it "seq() creates a matrix of integers, sequentially" do
+    m = NMatrix.seq(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        expect(m[i,j]).to eq(value)
+        value += 1
+      end
+    end
+  end
+
+
+  it "indgen() creates a matrix of integers as well as seq()" do
+    m = NMatrix.indgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        expect(m[i, j]).to eq(value)
+        value += 1
+      end
+    end
+  end
+
+  it "findgen creates a matrix of floats, sequentially" do
+    m = NMatrix.findgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        expect(m[i, j]/10).to be_within(Float::EPSILON).of(value.to_f/10)
+        value += 1
+      end
+    end
+  end
+
+  it "bindgen() creates a matrix of bytes" do
+    m = NMatrix.bindgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        expect(m[i, j]).to eq(value)
+        value += 1
+      end
+    end
+  end
+
+  it "cindgen() creates a matrix of complexes" do
+    m = NMatrix.cindgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        expect(m[i, j].real).to be_within(Float::EPSILON).of(value)
+        expect(m[i, j].imag).to be_within(Float::EPSILON).of(0.0)
+        value += 1
+      end
+    end
+  end
+
+  it "column() returns a NMatrix" do
+    m = NMatrix.random(3)
+
+    expect(m.column(2).is_a?(NMatrix)).to be_true
+  end
+
+  it "row() returns a NMatrix" do
+    m = NMatrix.random(3)
+
+    expect(m.row(2).is_a?(NMatrix)).to be_true
+  end
+
+  it "diagonals() creates an NMatrix" do
+    arr = [1,2,3,4]
+    m = NMatrix.diagonals(arr)
+    expect(m.is_a?(NMatrix)).to be_true
+  end
+
+  it "diagonals() contains the seeded values on the diagonal" do
+    arr = [1,2,3,4]
+    m = NMatrix.diagonals(arr)
+    expect(m[0,0]).to eq(arr[0])
+    expect(m[1,1]).to eq(arr[1])
+    expect(m[2,2]).to eq(arr[2])
+    expect(m[3,3]).to eq(arr[3])
+  end
+
+  context "_like constructors" do
+    before :each do
+      @nm_1d = NMatrix[5.0,0.0,1.0,2.0,3.0]
+      @nm_2d = NMatrix[[0.0,1.0],[2.0,3.0]]
+    end
+
+    it "should create an nmatrix of ones with dimensions and type the same as its argument" do
+      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
+
+    it "should create an nmatrix of zeros with dimensions and type the same as its argument" do
+      expect(NMatrix.zeros_like(@nm_1d)).to eq NMatrix[0.0, 0.0, 0.0, 0.0, 0.0]
+      expect(NMatrix.zeros_like(@nm_2d)).to eq NMatrix[[0.0, 0.0], [0.0, 0.0]]
+    end
+  end
+
+end
+
+describe "NVector" do
+
+  it "zeros() creates a vector of zeros" do
+    v = NVector.zeros(4)
+
+    4.times do |i|
+      expect(v[i]).to eq(0)
+    end
+  end
+
+  it "ones() creates a vector of ones" do
+    v = NVector.ones(3)
+
+    3.times do |i|
+      expect(v[i]).to eq(1)
+    end
+  end
+
+  it "random() creates a vector of random numbers" do
+    v = NVector.random(4)
+    expect(v.dtype).to eq(:float64)
+    expect(v.stype).to eq(:dense)
+  end
+
+  it "seq() creates a vector of integers, sequentially" do
+    v = NVector.seq(7)
+    expect(v).to eq(NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6]))
+  end
+
+  it "seq() only accepts integers as dimension" do
+    expect { NVector.seq(3) }.to_not raise_error
+
+    expect { NVector.seq([1, 3]) }.to raise_error
+    expect { NVector.seq(:wtf) }.to raise_error
+  end
+
+  it "indgen() creates a vector of integers as well as seq()" do
+    v = NVector.indgen(7)
+    expect(v).to eq(NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6]))
+  end
+
+  it "findgen creates a vector of floats, sequentially" do
+    v = NVector.findgen(2)
+    expect(v).to eq(NMatrix.new([2,1], [0.0, 1.0]))
+  end
+
+  it "bindgen() creates a vector of bytes, sequentially" do
+    v = NVector.bindgen(4)
+    expect(v).to eq(NMatrix.new([4,1], [0, 1, 2, 3], dtype: :byte))
+  end
+
+  it "cindgen() creates a vector of complexes, sequentially" do
+    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
+    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
+    v = NVector.logspace(0, 3, 4)
+    expect(v).to eq(NMatrix.new([4,1], [1.0, 10.0, 100.0, 1000.0]))
+  end
+end
+
+describe "Inline constructor" do
+
+  it "creates a NMatrix with the given values" do
+    m = NMatrix.new([2, 2], [1, 4, 6, 7])
+    n = NMatrix[[1, 4], [6, 7]]
+
+    expect(m).to eq n
+  end
+end

data/spec/slice_set_spec.rb

@@ -0,0 +1,157 @@
+# = 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
+#
+# == slice_set_spec.rb
+#
+# Test of slice set operations.
+
+require 'spec_helper'
+require 'pry'
+
+describe "Set slice operation" do
+  include RSpec::Longrun::DSL
+
+  [:dense, :yale, :list].each do |stype|
+    context "for #{stype}" do
+      before :each do
+        @m = create_matrix(stype)
+      end
+
+      example "set and unset a range of entries with single values" 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])
+            expect(@m.yale_a).to   eq([0,4,8,0, 1,2,3,5,6,7])
+          end
+        end
+
+        step "set and reset a single entry" do
+          n = @m.clone
+          old_val = @m[0,0]
+          @m[0,0] = 100
+          expect(@m[0,0]).to eq(100)
+          @m[0,0] = old_val
+          expect(@m).to eq(n)
+        end
+
+        if stype == :yale
+          n = @m.clone
+          step "set a row of entries" do
+            n[0,0..2] = 0
+            expect(n[0,0..2].to_flat_array).to eq([0,0,0])
+            expect(n[1,0..2].to_flat_array).to eq([3,4,5])
+            expect(n[2,0..2].to_flat_array).to eq([6,7,8])
+          end
+
+          step "set a second row of entries" do
+            n[2,0..2] = 0
+            expect(n[2,0..2].to_flat_array).to eq([0,0,0])
+            expect(n[1,0..2].to_flat_array).to eq([3,4,5])
+          end
+
+          step "reset both rows of entries" do
+            n[0,0..2] = [0,1,2]
+            n[2,0..2] = [6,7,8]
+            expect(n).to eq(@m)
+          end
+        end
+
+        slice_result_a = NMatrix.new(:dense, 2, 100, @m.dtype).cast(stype)
+        slice_result_b = NMatrix.new(:dense, 2, 0,   @m.dtype).cast(stype)
+        m = @m.clone
+
+        step "set upper left-hand 2x2 corner to 100" do
+          m[0..1,0..1] = 100
+
+          if stype == :yale
+            expect(m.yale_ija).to eq([4,   6,   8,   10,   1,   2,   0,   2,  0,  1])
+            expect(m.yale_a).to   eq([100, 100, 8,   0,   100,  2, 100,   5,  6,  7])
+          end
+
+          expect(m[0..1,0..1]).to eq(slice_result_a)
+          expect(m[2,0..1]).to eq(@m[2,0..1])
+          expect(m[0..1,2]).to eq(@m[0..1,2])
+        end
+
+        step "set upper left-hand 2x2 corner to 0" do
+          m[0..1,0..1] = 0
+          if stype == :yale
+            expect([4,5,6,8,2,2,0,1]).to eq(m.yale_ija)
+            expect([0,0,8,0,2,5,6,7]).to eq(m.yale_a)
+          end
+
+          expect(m[0..1,0..1]).to eq(slice_result_b)
+        end
+
+        m = @m.clone
+        step "set lower left-hand 2x2 corner to 100" do
+          m[1..2,0..1] = 100
+          expect(m[1..2,0..1]).to eq(slice_result_a)
+          expect(m[0,0..1]).to eq(@m[0,0..1])
+          expect(m[1..2,2]).to eq(@m[1..2,2])
+        end
+
+        step "set lower left-hand 2x2 corner to 0" do
+          m[1..2,0..1] = 0
+          expect(m[1..2,0..1]).to eq(slice_result_b)
+        end
+
+        m = @m.clone
+        step "set lower right-hand 2x2 corner to 100" do
+          m[1..2,1..2] = 100
+          expect(m[1..2,1..2]).to eq(slice_result_a)
+          expect(m[0,1..2]).to eq(@m[0,1..2])
+          expect(m[1..2,0]).to eq(@m[1..2,0])
+        end
+
+        step "set lower right-hand 2x2 corner to 0" do
+          m[1..2,1..2] = 0
+          expect(m[1..2,1..2]).to eq(slice_result_b)
+        end
+
+        m = @m.clone
+        step "set upper right-hand 2x2 corner to 100" do
+          m[0..1,1..2] = 100
+          expect(m[0..1,1..2]).to eq(slice_result_a)
+          expect(m[2,1..2]).to eq(@m[2,1..2])
+          expect(m[0..1,0]).to eq(@m[0..1,0])
+        end
+
+        step "set upper right-hand 2x2 corner to 0" do
+          m[0..1,1..2] = 0
+          expect(m[0..1,1..2]).to eq(slice_result_b)
+        end
+      end
+
+      example "set a range of values to a matrix's contents" do
+        x = NMatrix.new(4, stype: :yale, dtype: :int16)
+        x.extend NMatrix::YaleFunctions if stype == :yale
+        x[1..3,1..3] = @m
+        expect(x.to_flat_array).to eq([0,0,0,0, 0,0,1,2, 0,3,4,5, 0,6,7,8])
+      end
+
+    end
+  end
+
+end