pnmatrix 1.2.4

data/lib/nmatrix/enumerate.rb

@@ -0,0 +1,253 @@
+#--
+# = 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
+#
+# == enumerate.rb
+#
+# Enumeration methods for NMatrix
+#++
+
+class NMatrix
+  include Enumerable
+
+  ##
+  # call-seq:
+  #   each -> Enumerator
+  #
+  # Enumerate through the matrix. @see Enumerable#each
+  #
+  # For dense, this actually calls a specialized each iterator (in C). For yale and list, it relies upon
+  # #each_with_indices (which is about as fast as reasonably possible for C code).
+  def each &bl
+    if self.stype == :dense
+      self.__dense_each__(&bl)
+    elsif block_given?
+      self.each_with_indices(&bl)
+    else # Handle case where no block is given
+      Enumerator.new do |yielder|
+        self.each_with_indices do |params|
+          yielder.yield params
+        end
+      end
+    end
+  end
+
+  #
+  # call-seq:
+  #     flat_map -> Enumerator
+  #     flat_map { |elem| block } -> Array
+  #
+  # Maps using Enumerator (returns an Array or an Enumerator)
+  alias_method :flat_map, :map
+
+  ##
+  # call-seq:
+  #   map -> Enumerator
+  #   map { |elem| block } -> NMatrix
+  #
+  # Returns an NMatrix if a block is given. For an Array, use #flat_map
+  #
+  # Note that #map will always return an :object matrix, because it has no way of knowing
+  # how to handle operations on the different dtypes.
+  #
+  def map(&bl)
+    return enum_for(:map) unless block_given?
+    # NMatrix-jruby currently supports only doubles
+    cp  = jruby? ? self : self.cast(dtype: :object)
+    cp.map!(&bl)
+    cp
+  end
+
+  ##
+  # call-seq:
+  #   map! -> Enumerator
+  #   map! { |elem| block } -> NMatrix
+  #
+  # Maps in place.
+  # @see #map
+  #
+  def map!
+    return enum_for(:map!) unless block_given?
+    iterated = false
+    self.each_stored_with_indices do |e, *i|
+      iterated = true
+      self[*i] = (yield e)
+    end
+    #HACK: if there's a single element in a non-dense matrix, it won't iterate and
+    #won't change the default value; this ensures that it does get changed.
+    unless iterated then
+      self.each_with_indices do |e, *i|
+        self[*i] = (yield e)
+      end
+    end
+  end
+
+
+  #
+  # call-seq:
+  #     each_rank() -> NMatrix
+  #     each_rank() { |rank| block } -> NMatrix
+  #     each_rank(dimen) -> Enumerator
+  #     each_rank(dimen) { |rank| block } -> NMatrix
+  #
+  # Generic for @each_row, @each_col
+  #
+  # Iterate through each rank by reference.
+  #
+  # @param [Fixnum] dimen the rank being iterated over.
+  #
+  def each_rank(dimen=0, get_by=:reference)
+    return enum_for(:each_rank, dimen, get_by) unless block_given?
+    (0...self.shape[dimen]).each do |idx|
+      yield self.rank(dimen, idx, get_by)
+    end
+    self
+  end
+  alias :each_along_dim :each_rank
+
+  #
+  # call-seq:
+  #     each_row { |row| block } -> NMatrix
+  #
+  # Iterate through each row, referencing it as an NMatrix slice.
+  def each_row(get_by=:reference)
+    return enum_for(:each_row, get_by) unless block_given?
+    (0...self.shape[0]).each do |i|
+      yield self.row(i, get_by)
+    end
+    self
+  end
+
+  #
+  # call-seq:
+  #     each_column { |column| block } -> NMatrix
+  #
+  # Iterate through each column, referencing it as an NMatrix slice.
+  def each_column(get_by=:reference)
+    return enum_for(:each_column, get_by) unless block_given?
+    (0...self.shape[1]).each do |j|
+      yield self.column(j, get_by)
+    end
+    self
+  end
+
+  #
+  # call-seq:
+  #     each_layer -> { |column| block } -> ...
+  #
+  # Iterate through each layer, referencing it as an NMatrix slice.
+  #
+  # Note: If you have a 3-dimensional matrix, the first dimension contains rows,
+  # the second contains columns, and the third contains layers.
+  def each_layer(get_by=:reference)
+    return enum_for(:each_layer, get_by) unless block_given?
+    (0...self.shape[2]).each do |k|
+      yield self.layer(k, get_by)
+    end
+    self
+  end
+
+
+  #
+  # call-seq:
+  #     each_stored_with_index -> Enumerator
+  #
+  # Allow iteration across a vector NMatrix's stored values. See also @each_stored_with_indices
+  #
+  def each_stored_with_index(&block)
+    raise(NotImplementedError, "only works for dim 2 vectors") unless self.dim <= 2
+    return enum_for(:each_stored_with_index) unless block_given?
+
+    self.each_stored_with_indices do |v, i, j|
+      if shape[0] == 1
+        yield(v,j)
+      elsif shape[1] == 1
+        yield(v,i)
+      else
+        method_missing(:each_stored_with_index, &block)
+      end
+    end
+    self
+  end
+
+
+  ##
+  # call-seq:
+  #   inject_rank() -> Enumerator
+  #   inject_rank(dimen) -> Enumerator
+  #   inject_rank(dimen, initial) -> Enumerator
+  #   inject_rank(dimen, initial, dtype) -> Enumerator
+  #   inject_rank() { |elem| block } -> NMatrix
+  #   inject_rank(dimen) { |elem| block } -> NMatrix
+  #   inject_rank(dimen, initial) { |elem| block } -> NMatrix
+  #   inject_rank(dimen, initial, dtype) { |elem| block } -> NMatrix
+  #
+  # Reduces an NMatrix using a supplied block over a specified dimension.
+  # The block should behave the same way as for Enumerable#reduce.
+  #
+  # @param [Integer] dimen the dimension being reduced
+  # @param [Numeric] initial the initial value for the reduction
+  #  (i.e. the usual parameter to Enumerable#reduce).  Supply nil or do not
+  #  supply this argument to have it follow the usual Enumerable#reduce
+  #  behavior of using the first element as the initial value.
+  # @param [Symbol] dtype if non-nil/false, forces the accumulated result to have this dtype
+  # @return [NMatrix] an NMatrix with the same number of dimensions as the
+  #  input, but with the input dimension now having size 1.  Each element
+  #  is the result of the reduction at that position along the specified
+  #  dimension.
+  #
+  def inject_rank(dimen=0, initial=nil, dtype=nil)
+
+    raise(RangeError, "requested dimension (#{dimen}) does not exist (shape: #{shape})") if dimen > self.dim
+
+    return enum_for(:inject_rank, dimen, initial, dtype) unless block_given?
+
+    new_shape = shape.dup
+    new_shape[dimen] = 1
+
+    first_as_acc = false
+
+    if initial then
+      acc = NMatrix.new(new_shape, initial, :dtype => dtype || self.dtype, stype: self.stype)
+    else
+      each_rank(dimen) do |sub_mat|
+        acc = (sub_mat.is_a?(NMatrix) and !dtype.nil? and dtype != self.dtype) ? sub_mat.cast(self.stype, dtype) : sub_mat
+        break
+      end
+      first_as_acc = true
+    end
+
+    each_rank(dimen) do |sub_mat|
+      if first_as_acc
+        first_as_acc = false
+        next
+      end
+      acc = yield(acc, sub_mat)
+    end
+
+    acc
+  end
+
+  alias :reduce_along_dim :inject_rank
+  alias :inject_along_dim :inject_rank
+
+end

data/lib/nmatrix/homogeneous.rb

@@ -0,0 +1,241 @@
+#--
+# = 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.rb
+#
+# This file contains optional shortcuts for generating homogeneous
+# transformations.
+#
+#++
+
+class NMatrix
+  class << self
+    #
+    # call-seq:
+    #     x_rotation(angle_in_radians) -> NMatrix
+    #     x_rotation(angle_in_radians, dtype: dtype) -> NMatrix
+    #     y_rotation(angle_in_radians) -> NMatrix
+    #     y_rotation(angle_in_radians, dtype: dtype) -> NMatrix
+    #     z_rotation(angle_in_radians) -> NMatrix
+    #     z_rotation(angle_in_radians, dtype: dtype) -> NMatrix
+    #
+    # Generate a 4x4 homogeneous transformation matrix representing a rotation
+    # about the x, y, or z axis respectively.
+    #
+    # * *Arguments* :
+    #   - +angle_in_radians+ -> The angle of rotation in radians.
+    #   - +dtype+ -> (optional) Default is +:float64+
+    # * *Returns* :
+    #   - A homogeneous transformation matrix consisting of a single rotation.
+    #
+    # Examples:
+    #
+    #    NMatrix.x_rotation(Math::PI.quo(6)) # =>
+    #                                              1.0      0.0       0.0       0.0
+    #                                              0.0      0.866025 -0.499999  0.0
+    #                                              0.0      0.499999  0.866025  0.0
+    #                                              0.0      0.0       0.0       1.0
+    #
+    #
+    #    NMatrix.x_rotation(Math::PI.quo(6), dtype: :float32) # =>
+    #                                              1.0      0.0       0.0       0.0
+    #                                              0.0      0.866025 -0.5       0.0
+    #                                              0.0      0.5       0.866025  0.0
+    #                                              0.0      0.0       0.0       1.0
+    #
+    def x_rotation angle_in_radians, opts={}
+      c = Math.cos(angle_in_radians)
+      s = Math.sin(angle_in_radians)
+      NMatrix.new(4, [1.0, 0.0, 0.0, 0.0,
+                      0.0, c,   -s,  0.0,
+                      0.0, s,    c,  0.0,
+                      0.0, 0.0, 0.0, 1.0], {dtype: :float64}.merge(opts))
+    end
+
+    def y_rotation angle_in_radians, opts={}
+      c = Math.cos(angle_in_radians)
+      s = Math.sin(angle_in_radians)
+      NMatrix.new(4, [ c,  0.0,  s,  0.0,
+                      0.0, 1.0, 0.0, 0.0,
+                      -s,  0.0,  c,  0.0,
+                      0.0, 0.0, 0.0, 1.0], {dtype: :float64}.merge(opts))
+    end
+
+    def z_rotation angle_in_radians, opts={}
+      c = Math.cos(angle_in_radians)
+      s = Math.sin(angle_in_radians)
+      NMatrix.new(4, [ c,  -s,  0.0, 0.0,
+                       s,   c,  0.0, 0.0,
+                      0.0, 0.0, 1.0, 0.0,
+                      0.0, 0.0, 0.0, 1.0], {dtype: :float64}.merge(opts))
+    end
+
+
+    #
+    # call-seq:
+    #     translation(x, y, z) -> NMatrix
+    #     translation([x,y,z]) -> NMatrix
+    #     translation(translation_matrix) -> NMatrix
+    #     translation(translation_matrix) -> NMatrix
+    #     translation(translation, dtype: dtype) -> NMatrix
+    #     translation(x, y, z, dtype: dtype) -> NMatrix
+    #
+    # Generate a 4x4 homogeneous transformation matrix representing a translation.
+    #
+    # * *Returns* :
+    #   - A homogeneous transformation matrix consisting of a translation.
+    #
+    # Examples:
+    #
+    #    NMatrix.translation(4.0,5.0,6.0) # =>
+    #                                          1.0   0.0   0.0   4.0
+    #                                          0.0   1.0   0.0   5.0
+    #                                          0.0   0.0   1.0   6.0
+    #                                          0.0   0.0   0.0   1.0
+    #
+    #    NMatrix.translation(4.0,5.0,6.0, dtype: :int64) # =>
+    #                                                         1  0  0  4
+    #                                                         0  1  0  5
+    #                                                         0  0  1  6
+    #                                                         0  0  0  1
+    #    NMatrix.translation(4,5,6) # =>
+    #                                     1  0  0  4
+    #                                     0  1  0  5
+    #                                     0  0  1  6
+    #                                     0  0  0  1
+    #
+    def translation *args
+      xyz = args.shift if args.first.is_a?(NMatrix) || args.first.is_a?(Array)
+      default_dtype = xyz.respond_to?(:dtype) ? xyz.dtype : NMatrix.guess_dtype(xyz)
+      opts = {dtype: default_dtype}
+      opts = opts.merge(args.pop) if args.size > 0 && args.last.is_a?(Hash)
+      xyz ||= args
+
+      n = if args.size > 0
+        NMatrix.eye(4, opts)
+      else
+        NMatrix.eye(4, opts)
+      end
+      n[0..2,3] = xyz
+      n
+    end
+  end
+
+  #
+  # call-seq:
+  #     quaternion -> NMatrix
+  #
+  # Find the quaternion for a 3D rotation matrix.
+  #
+  # Code borrowed from: http://courses.cms.caltech.edu/cs171/quatut.pdf
+  #
+  # * *Returns* :
+  #   - A length-4 NMatrix representing the corresponding quaternion.
+  #
+  # Examples:
+  #
+  #    n.quaternion # => [1, 0, 0, 0]
+  #
+  def quaternion
+    raise(ShapeError, "Expected square matrix") if self.shape[0] != self.shape[1]
+    raise(ShapeError, "Expected 3x3 rotation (or 4x4 homogeneous) matrix") if self.shape[0] > 4 || self.shape[0] < 3
+
+    q = NMatrix.new([4], dtype: self.dtype == :float32 ? :float32: :float64)
+    rotation_trace = self[0,0] + self[1,1] + self[2,2]
+    if rotation_trace >= 0
+      self_w = self.shape[0] == 4 ? self[3,3] : 1.0
+      root_of_homogeneous_trace = Math.sqrt(rotation_trace + self_w)
+      q[0] = root_of_homogeneous_trace * 0.5
+      s = 0.5 / root_of_homogeneous_trace
+      q[1] = (self[2,1] - self[1,2]) * s
+      q[2] = (self[0,2] - self[2,0]) * s
+      q[3] = (self[1,0] - self[0,1]) * s
+    else
+      h = 0
+      h = 1 if self[1,1] > self[0,0]
+      h = 2 if self[2,2] > self[h,h]
+
+      case_macro = Proc.new do |i,j,k,ii,jj,kk|
+        qq = NMatrix.new([4], dtype: :float64)
+        self_w = self.shape[0] == 4 ? self[3,3] : 1.0
+        s = Math.sqrt( (self[ii,ii] - (self[jj,jj] + self[kk,kk])) + self_w)
+        qq[i] = s*0.5
+        s = 0.5 / s
+        qq[j] = (self[ii,jj] + self[jj,ii]) * s
+        qq[k] = (self[kk,ii] + self[ii,kk]) * s
+        qq[0] = (self[kk,jj] - self[jj,kk]) * s
+        qq
+      end
+
+      case h
+      when 0
+        q = case_macro.call(1,2,3, 0,1,2)
+      when 1
+        q = case_macro.call(2,3,1, 1,2,0)
+      when 2
+        q = case_macro.call(3,1,2, 2,0,1)
+      end
+
+      self_w = self.shape[0] == 4 ? self[3,3] : 1.0
+      if self_w != 1
+        s = 1.0 / Math.sqrt(self_w)
+        q[0] *= s
+        q[1] *= s
+        q[2] *= s
+        q[3] *= s
+      end
+    end
+
+    q
+  end
+
+  #
+  # call-seq:
+  #     angle_vector -> [angle, about_vector]
+  #
+  # Find the angle vector for a quaternion. Assumes the quaternion has unit length.
+  #
+  # Source: http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/
+  #
+  # * *Returns* :
+  #   - An angle (in radians) describing the rotation about the +about_vector+.
+  #   - A length-3 NMatrix representing the corresponding quaternion.
+  #
+  # Examples:
+  #
+  #    q.angle_vector # => [1, 0, 0, 0]
+  #
+  def angle_vector
+    raise(ShapeError, "Expected length-4 vector or matrix (quaternion)") if self.shape[0] != 4
+    raise("Expected unit quaternion") if self[0] > 1
+
+    xyz = NMatrix.new([3], dtype: self.dtype)
+
+    angle = 2 * Math.acos(self[0])
+    s = Math.sqrt(1.0 - self[0]*self[0])
+
+    xyz[0..2] = self[1..3]
+    xyz /= s if s >= 0.001 # avoid divide by zero
+    return [angle, xyz]
+  end
+end

data/lib/nmatrix/io/fortran_format.rb

@@ -0,0 +1,138 @@
+#--
+# = 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 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, 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/matlab/fortran_format.rb
+#
+# A parser for making sense of FORTRAN formats.
+# => Only handles R (real), F (float) and E (exponential) format codes. 
+#++
+
+class NMatrix
+  module IO
+    module FortranFormat
+
+      # Class for reading strings in FORTRAN format for specifying attributes
+      # of numerical data in a file. Supports F (float), E (exponential) and 
+      # R (real).
+      # 
+      # == Usage
+      # 
+      #   p = NMatrix::IO::FortranFormat::Reader.new("(16I5)")
+      #   v = p.parse
+      #   puts v #=> { :format_code => "INT_ID", 
+      #          #=>   :repeat      =>       16,
+      #          #=>   :field_width =>        5 }
+      class Reader
+
+        # Accepts a string in FORTRAN format and initializes the 
+        # NMatrix::IO::FortranFormat::Reader object for further parsing of the 
+        # data.
+        # 
+        # == Arguments
+        # 
+        # * +string+ - FORTRAN format string to be parsed.
+        def initialize string
+          @string = string
+        end
+
+        # Parses the FORTRAN format string passed in initialize and returns
+        # a hash of the results.
+        # 
+        # == Result Hash Format
+        # 
+        # Take note that some of the below parameters may be absent in the hash
+        # depending on the type of string being parsed.
+        # 
+        # * +:format_code+ - A string containing the format code of the read data. 
+        #                    Can be "INT_ID", "FP_ID" or "EXP_ID" 
+        # * +:repeat+      - Number of times this format will repeat in a line.
+        # * +:field_width+ - Width of the numerical part of the number.
+        # * +:post_decimal_width+ - Width of the numerals after the decimal point.
+        # * +:exponent_width+ - Width of exponent part of the number.
+        def parse
+          raise(IOError, "Left or right parentheses missing") \
+           if parentheses_missing? # change tests to handle 'raise' not return
+
+          @result = {}
+          @string = @string[1..-2]
+
+          if valid_fortran_format?
+            load_result
+          else
+            raise(IOError, "Invalid FORTRAN format specified. Only Integer, Float or Exponential acceptable.")
+          end
+
+          @result
+        end
+
+       private
+        def parentheses_missing?
+          true if @string[0] != '(' or @string[-1] != ')'
+        end
+
+        # Changing any of the following regular expressions can lead to disaster
+        def valid_fortran_format?
+          @mdata = @string.match(/\A(\d*)(I)(\d+)\z/) # check for integer format
+          @mdata = @string.match(/\A(\d*)(F)(\d+)\.(\d+)\z/) \
+           if @mdata.nil? # check for floating point if not integer
+          @mdata =  @string.match(/\A(\d*)(E)(\d+)\.(\d+)(E)?(\d*)\z/) \
+           if @mdata.nil? # check for exponential format if not floating point
+
+          @mdata
+        end
+
+        def load_result
+          if @mdata.to_a.include? "I"
+            create_integer_hash
+          elsif @mdata.to_a.include? "F"
+            create_float_hash
+          else
+            create_exp_hash
+          end
+        end
+
+        def create_integer_hash
+          @result[:format_code] = "INT_ID"
+          @result[:repeat]      = @mdata[1].to_i if !@mdata[1].empty?
+          @result[:field_width] = @mdata[3].to_i
+        end
+
+        def create_float_hash
+          @result[:format_code]        = "FP_ID"
+          @result[:repeat]             = @mdata[1].to_i if !@mdata[1].empty?
+          @result[:field_width]        = @mdata[3].to_i
+          @result[:post_decimal_width] = @mdata[4].to_i
+        end
+
+        def create_exp_hash
+          @result[:format_code]        = "EXP_ID"
+          @result[:repeat]             = @mdata[1].to_i if !@mdata[1].empty?
+          @result[:field_width]        = @mdata[3].to_i
+          @result[:post_decimal_width] = @mdata[4].to_i
+          @result[:exponent_width]     = @mdata[6].to_i if !@mdata[6].empty?
+        end
+      end
+      
+    end
+  end
+end