nmatrix 0.2.1 → 0.2.3

data/lib/nmatrix/nmatrix.rb

@@ -534,6 +534,16 @@ class NMatrix
     rank(0, row_number, get_by)
   end
 
+  #
+  # call-seq:
+  #     last -> Element of self.dtype
+  #
+  # Returns the last element stored in an NMatrix
+  #
+  def last
+    self[*Array.new(self.dim, -1)]
+  end
+
 
   #
   # call-seq:
@@ -700,16 +710,20 @@ class NMatrix
     # Do the actual construction.
     n = NMatrix.new(new_shape, opts)
 
-    # Figure out where to start and stop the concatenation. We'll use NMatrices instead of
-    # Arrays because then we can do elementwise addition.
-    ranges = self.shape.map.with_index { |s,i| 0...self.shape[i] }
+    # Figure out where to start concatenation. We don't know where it will end,
+    # because each matrix may have own size along concat dimension.
+    pos = Array.new(self.dim) { 0 }
 
     matrices.unshift(self)
     matrices.each do |m|
+      # Figure out where to start and stop the concatenation. We'll use
+      # NMatrices instead of Arrays because then we can do elementwise addition.
+      ranges = m.shape.map.with_index { |s,i| pos[i]...(pos[i] + s) }
+
       n[*ranges] = m
 
-      # move over by the requisite amount
-      ranges[rank]  = (ranges[rank].first + m.shape[rank])...(ranges[rank].last + m.shape[rank])
+      # Move over by the requisite amount
+      pos[rank] = pos[rank] + m.shape[rank]
     end
 
     n
@@ -1011,7 +1025,7 @@ class NMatrix
     raise(ArgumentError, 'Matrix should be repeated at least 2 times.') if count < 2
     new_shape = shape
     new_shape[axis] *= count
-    new_matrix = NMatrix.new(new_shape)
+    new_matrix = NMatrix.new(new_shape, dtype: dtype)
     slice = new_shape.map { |axis_size| 0...axis_size }
     start = 0
     count.times do

data/lib/nmatrix/shortcuts.rb

@@ -34,6 +34,92 @@
 
 class NMatrix
 
+  # Methods for generating magic matrix.
+  module MagicHelpers
+    class << self
+      def odd_magic(nm, shape)
+        row = shape - 1
+        col = shape / 2       
+        nm[row,col] = 1
+        (2..shape * shape).each do |index|
+          if nm[(row + 1) % shape,(col + 1) % shape] == 0
+            row = (row + 1) % shape
+            col = (col + 1) % shape
+          else
+            row = (row - 1 + shape) % shape
+          end
+            nm[row,col] = index
+        end
+      end
+    
+      def doubly_even_magic(nm, shape)
+        mini_square_num = shape / 4
+        count = 1     
+        inv_count = shape * shape
+        shape.times do |row|
+          shape.times do |col|
+            if col >= mini_square_num and col < shape - mini_square_num
+              if row >= mini_square_num and row < shape - mini_square_num
+      	        nm[row,col] = count
+              else 
+                nm[row,col] = inv_count
+              end
+            elsif row < mini_square_num or row >= shape - mini_square_num
+              nm[row,col] = count
+            else
+              nm[row,col] = inv_count
+            end
+            count += 1
+            inv_count -= 1  
+          end
+        end
+      end
+    
+      def singly_even_magic(nm, shape)
+        half_shape = shape / 2
+        complementary_pair = (shape - 2) / 4
+        swap_col = NMatrix.new([shape])
+        index = 0 
+        mini_magic = NMatrix.new([half_shape,half_shape], 0, dtype: nm.dtype)
+        odd_magic mini_magic, half_shape
+        half_shape.times do |row|
+          half_shape.times do |col|
+            nm[row,col] = mini_magic[row,col]  	
+            nm[row + half_shape,col + half_shape] = mini_magic[row,col] + half_shape * half_shape  
+            nm[row,col + half_shape] = mini_magic[row,col] + 2 * half_shape * half_shape      
+            nm[row + half_shape,col] = mini_magic[row,col] + 3 * half_shape * half_shape       
+          end  
+        end
+  
+        (1..complementary_pair).each do |complementary_entry|
+          swap_col[index] = complementary_entry
+          index += 1
+        end
+      
+        (shape - complementary_pair + 2..shape).each do |center|
+          swap_col[index] = center
+          index += 1
+        end 
+      
+        (1..half_shape).each do |row|
+          (1..index).each do |col|
+            temp = nm[row - 1,swap_col[col - 1] - 1]
+            nm[row - 1,swap_col[col - 1] - 1] = nm[row + half_shape - 1,swap_col[col - 1] - 1]
+            nm[row + half_shape - 1,swap_col[col - 1] - 1] = temp
+          end
+        end
+
+        temp = nm[complementary_pair,0] 
+        nm[complementary_pair,0] = nm[complementary_pair + half_shape,0] 
+        nm[complementary_pair + half_shape,0] = temp
+
+        temp = nm[complementary_pair + half_shape,complementary_pair]
+        nm[complementary_pair + half_shape,complementary_pair] = nm[complementary_pair,complementary_pair] 
+        nm[complementary_pair,complementary_pair] = temp
+      end  
+    end 
+  end 
+    
   # call-seq:
   #     m.dense? -> true or false
   #
@@ -236,6 +322,86 @@ class NMatrix
       m
     end
     alias :identity :eye
+
+    #
+    # call-seq:
+    #     hilbert(shape) -> NMatrix
+    #     hilbert(shape, dtype: dtype) -> NMatrix
+    #     hilbert(shape, stype: stype, dtype: dtype) -> NMatrix
+    #
+    # Creates an hilbert matrix (square matrix).
+    #
+    # * *Arguments* :
+    #   - +size+ -> integer ( for square matrix) specifying the dimensions.
+    #   - +dtype+ -> (optional) Default is +:float64+
+    #   - +stype+ -> (optional) Default is +:dense+.
+    # * *Returns* :
+    #   - A hilbert matrix.
+    #
+    # Examples:
+    #
+    #    NMatrix.hilbert(3) # =>  1.0     0.5      0.3333333333333333
+    #            0.5                         0.3333333333333333    0.25
+    #            0.3333333333333333          0.25                  0.2
+    #
+    def hilbert(shape, opts={})
+      m = NMatrix.new([shape,shape], {:dtype => :float64}.merge(opts))
+      0.upto(shape - 1) do |i|
+        0.upto(i) do |j|
+          m[i,j] = 1.0 / (j + i + 1)
+          m[j,i] = m[i,j] if i != j
+        end
+      end
+      m
+    end
+
+    #
+    # call-seq:
+    #     inv_hilbert(shape) -> NMatrix
+    #     inv_hilbert(shape, dtype: dtype) -> NMatrix
+    #     inv_hilbert(shape, stype: stype, dtype: dtype) -> NMatrix
+    #
+    # Creates an inverse hilbert matrix (square matrix rank 2).
+    #
+    # * *Arguments* :
+    #   - +size+ -> Array (or integer for square matrix) specifying the dimensions.
+    #   - +dtype+ -> (optional) Default is +:float64+
+    #   - +stype+ -> (optional) Default is +:dense+.
+    # * *Returns* :
+    #   - A hilbert matrix.
+    #
+    # Examples:
+    #    NMatrix.inv_hilbert(3) # =>   9.0,  -36.0,   30.0
+    #                          -36.0,  192.0, -180.0
+    #                          30.0, -180.0,  180.0
+    #
+    #
+    def inv_hilbert(shape, opts={})
+      opts = {:dtype => :float64}.merge(opts)
+      m = NMatrix.new([shape,shape],opts)
+      combination = NMatrix.new([2*shape,2*shape],opts)
+      #combinations refers to the combination of n things taken k at a time
+      0.upto(2*shape-1) do |i|
+        0.upto(i) do |j|
+          if j != 0 and j != i
+            combination[i,j] = combination[i-1,j] + combination[i-1,j-1]
+          else
+            combination[i,j] = 1
+          end
+        end
+      end
+
+      0.upto(shape-1) do |i|
+        0.upto(i) do |j|
+          m[i,j] = combination[shape + j,shape - i - 1] * ((i+j)+1) * \
+          combination[shape + i,shape - j - 1] * (-1) ** ((i+j)) * \
+          combination[(i+j),i] * combination[(i+j),i]
+          m[j,i] = m[i,j] if i != j
+        end
+      end
+      m
+    end
+
     #
     # call-seq:
     #     diagonals(array) -> NMatrix
@@ -385,6 +551,255 @@ class NMatrix
       NMatrix.new(shape, random_values, {:dtype => :float64, :stype => :dense}.merge(opts))
     end
     alias :rand :random
+    
+    # 
+    #  call-seq:
+    #    magic(shape) -> NMatrix
+    #    magic(shape, dtype: dtype) -> NMatrix
+    #
+    #  The parameter is the dimension of the matrix.
+    #
+    #  Creates a +:dense+ NMatrix with the following properties:
+    #    - An arrangement of the numbers from 1 to n^2 (n-squared) in the matrix, with each number occurring exactly once.
+    #    - The sum of the entries of any row, any column, or any main diagonal is the same.
+    #    - This sum must be n(n^2+1)/2.
+    #   
+    #  See: http://www.mathworks.com/help/matlab/ref/magic.html
+    # 
+    #  * *Arguments* :
+    #   - +shape+ -> Array (or integer for square matrix) specifying the dimensions.
+    #   - +dtype+ -> (optional) Default is +:float64+
+    #  * *Returns* :
+    #   - NMatrix with the above given properties.
+    #
+    #  Examples:
+    #       
+    #    NMatrix.magic(3) # => [  [4.0, 9.0, 2.0]   [3.0, 5.0, 7.0]   [8.0, 1.0, 6.0] ]
+    #    
+    #    NMatrix.magic(4, dtype :int32) # => [  [ 1, 15, 14,  4]
+    #                                           [12,  6,  7,  9]
+    #                                           [ 8, 10, 11,  5]
+    #                                           [13,  3,  2, 16] ]
+    #                             
+    #    NMatrix.magic(6,dtype: :int64) # => [  [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] ]
+    #
+    def magic(shape, opts={})
+      raise(ArgumentError, "shape of two is not allowed") if shape == 2
+      nm = NMatrix.new([shape,shape], 0, {:dtype => :float64}.merge(opts))
+      if shape % 2 != 0
+        MagicHelpers.odd_magic nm, shape
+      elsif shape % 4 == 0
+        MagicHelpers.doubly_even_magic nm, shape
+      else   
+        MagicHelpers.singly_even_magic nm, shape
+      end
+      nm
+    end
+    
+    #
+    # call-seq:
+    #     linspace(base, limit) -> 1x100 NMatrix
+    #     linspace(base, limit, *shape) -> NMatrix
+    #
+    # Returns an NMatrix with +[shape[0] x shape[1] x .. x shape[dim-1]]+ values of dtype +:float64+ equally spaced from
+    # +base+ to +limit+, inclusive.
+    #
+    # See: http://www.mathworks.com/help/matlab/ref/linspace.html
+    #
+    # * *Arguments* :
+    #   - +base+ -> The first value in the sequence.
+    #   - +limit+ -> The last value in the sequence.
+    #   - +shape+ -> Desired output shape. Default returns a 1x100 row vector.
+    # * *Returns* :
+    #   - NMatrix with +:float64+ values.
+    #
+    # Examples :-
+    #
+    #   NMatrix.linspace(1,Math::PI, 6)
+    #     =>[1.0,
+    #        1.4283185005187988,
+    #        1.8566370010375977,
+    #        2.2849555015563965,
+    #        2.7132740020751953,
+    #        3.1415927410125732
+    #       ]
+    #
+    #   NMatrix.linspace(1,10, [3,2])
+    #     =>[
+    #         [              1.0, 2.799999952316284]
+    #         [4.599999904632568, 6.400000095367432]
+    #         [8.199999809265137,              10.0]
+    #       ]
+    #
+    def linspace(base, limit, shape = [100])
+      
+      # Convert shape to array format 
+      shape = [shape] if shape.is_a? Integer 
+      
+      #Calculate number of elements 
+      count = shape.inject(:*)
+            
+      # Linear spacing between elements calculated in step
+      #   step = limit - base / (count - 1)
+      #   [Result Sequence] = [0->N sequence] * step + [Base]
+      step = (limit - base) * (1.0 / (count - 1))
+      result = NMatrix.seq(shape, {:dtype => :float64}) * step
+      result += NMatrix.new(shape, base)
+      result
+    end
+
+    # call-seq:
+    #     logspace(base, limit) -> 1x50 NMatrix with exponent_base = 10 
+    #     logspace(base, limit, shape , exponent_base:) -> NMatrix
+    #     logspace(base, :pi, n) -> 1xn NMatrix with interval [10 ^ base, Math::PI]
+    #
+    # Returns an NMatrix with +[shape[0] x shape[1] x .. x shape[dim-1]]+ values of dtype +:float64+ logarithmically spaced from
+    # +exponent_base ^ base+ to +exponent_base ^ limit+, inclusive.
+    #
+    # See: http://www.mathworks.com/help/matlab/ref/logspace.html
+    #
+    # * *Arguments* :
+    #   - +base+ -> exponent_base ** base is the first value in the sequence
+    #   - +limit+ -> exponent_base ** limit is the last value in the sequence.
+    #   - +shape+ -> Desired output shape. Default returns a 1x50 row vector.
+    # * *Returns* :
+    #   - NMatrix with +:float64+ values.
+    #
+    # Examples :-
+    #
+    #   NMatrix.logspace(1,:pi,7)
+    #     =>[
+    #         10.0000, 
+    #         8.2450, 
+    #         6.7980, 
+    #         5.6050, 
+    #         4.6213, 
+    #         3.8103, 
+    #         3.1416
+    #       ]
+    #
+    #   NMatrix.logspace(1,2,[3,2])
+    #     =>[
+    #         [10.0, 15.8489]
+    #         [25.1189, 39.8107]
+    #         [63.0957, 100.0]
+    #       ]
+    #
+    def logspace(base, limit, shape = [50], exponent_base: 10)
+
+      #Calculate limit for [10 ^ base ... Math::PI] if limit = :pi
+      limit = Math.log(Math::PI, exponent_base = 10) if limit == :pi 
+      shape = [shape] if shape.is_a? Integer
+
+      #[base...limit]  -> [exponent_base ** base ... exponent_base ** limit]
+      result = NMatrix.linspace(base, limit, shape)
+      result.map {|element| exponent_base ** element}
+    end
+
+    #
+    # call-seq:
+    #     linspace(base, limit) -> 1x100 NMatrix
+    #     linspace(base, limit, *shape) -> NMatrix
+    #
+    # Returns an NMatrix with +[shape[0] x shape[1] x .. x shape[dim-1]]+ values of dtype +:float64+ equally spaced from
+    # +base+ to +limit+, inclusive.
+    #
+    # See: http://www.mathworks.com/help/matlab/ref/linspace.html
+    #
+    # * *Arguments* :
+    #   - +base+ -> The first value in the sequence.
+    #   - +limit+ -> The last value in the sequence.
+    #   - +shape+ -> Desired output shape. Default returns a 1x100 row vector.
+    # * *Returns* :
+    #   - NMatrix with +:float64+ values.
+    #
+    # Examples :-
+    #
+    #   NMatrix.linspace(1,Math::PI, 6)
+    #     =>[1.0,
+    #        1.4283185005187988,
+    #        1.8566370010375977,
+    #        2.2849555015563965,
+    #        2.7132740020751953,
+    #        3.1415927410125732
+    #       ]
+    #
+    #   NMatrix.linspace(1,10, [3,2])
+    #     =>[
+    #         [              1.0, 2.799999952316284]
+    #         [4.599999904632568, 6.400000095367432]
+    #         [8.199999809265137,              10.0]
+    #       ]
+    #
+    def linspace(base, limit, shape = [100])
+      
+      # Convert shape to array format 
+      shape = [shape] if shape.is_a? Integer 
+      
+      #Calculate number of elements 
+      count = shape.inject(:*)
+            
+      # Linear spacing between elements calculated in step
+      #   step = limit - base / (count - 1)
+      #   [Result Sequence] = [0->N sequence] * step + [Base]
+      step = (limit - base) * (1.0 / (count - 1))
+      result = NMatrix.seq(shape, {:dtype => :float64}) * step
+      result += NMatrix.new(shape, base)
+      result
+    end
+
+    # call-seq:
+    #     logspace(base, limit) -> 1x50 NMatrix with exponent_base = 10 
+    #     logspace(base, limit, shape , exponent_base:) -> NMatrix
+    #     logspace(base, :pi, n) -> 1xn NMatrix with interval [10 ^ base, Math::PI]
+    #
+    # Returns an NMatrix with +[shape[0] x shape[1] x .. x shape[dim-1]]+ values of dtype +:float64+ logarithmically spaced from
+    # +exponent_base ^ base+ to +exponent_base ^ limit+, inclusive.
+    #
+    # See: http://www.mathworks.com/help/matlab/ref/logspace.html
+    #
+    # * *Arguments* :
+    #   - +base+ -> exponent_base ** base is the first value in the sequence
+    #   - +limit+ -> exponent_base ** limit is the last value in the sequence.
+    #   - +shape+ -> Desired output shape. Default returns a 1x50 row vector.
+    # * *Returns* :
+    #   - NMatrix with +:float64+ values.
+    #
+    # Examples :-
+    #
+    #   NMatrix.logspace(1,:pi,7)
+    #     =>[
+    #         10.0000, 
+    #         8.2450, 
+    #         6.7980, 
+    #         5.6050, 
+    #         4.6213, 
+    #         3.8103, 
+    #         3.1416
+    #       ]
+    #
+    #   NMatrix.logspace(1,2,[3,2])
+    #     =>[
+    #         [10.0, 15.8489]
+    #         [25.1189, 39.8107]
+    #         [63.0957, 100.0]
+    #       ]
+    #
+    def logspace(base, limit, shape = [50], exponent_base: 10)
+
+      #Calculate limit for [10 ^ base ... Math::PI] if limit = :pi
+      limit = Math.log(Math::PI, exponent_base = 10) if limit == :pi 
+      shape = [shape] if shape.is_a? Integer
+
+      #[base...limit]  -> [exponent_base ** base ... exponent_base ** limit]
+      result = NMatrix.linspace(base, limit, shape)
+      result.map {|element| exponent_base ** element}
+    end
 
     #
     # call-seq: