nmatrix 0.0.6 → 0.0.7

data/ext/nmatrix/storage/yale.h

@@ -90,6 +90,7 @@ extern "C" {
   YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* shape, void* ia, void* ja, void* a, nm::dtype_t from_dtype);
   YALE_STORAGE*	nm_yale_storage_create_merged(const YALE_STORAGE* merge_template, const YALE_STORAGE* other);
   void          nm_yale_storage_delete(STORAGE* s);
+  void          nm_yale_storage_delete_ref(STORAGE* s);
   void					nm_yale_storage_init(YALE_STORAGE* s, void* default_val);
   void					nm_yale_storage_mark(void*);
 
@@ -221,6 +222,9 @@ namespace nm { namespace yale_storage {
 
   template <typename IType>
   size_t  get_size(const YALE_STORAGE* storage);
+
+  template <typename IType>
+  IType binary_search_left_boundary(const YALE_STORAGE* s, IType left, IType right, IType bound);
 }} // end of namespace nm::yale_storage
 
 #endif // YALE_H

data/lib/nmatrix.rb

@@ -26,7 +26,7 @@
 #
 
 # For some reason nmatrix.so ends up in a different place during gem build.
-if File.exist? "lib/nmatrix/nmatrix.so"
+if File.exist?("lib/nmatrix/nmatrix.so") #|| File.exist?("lib/nmatrix/nmatrix.bundle")
   # Development
   require "nmatrix/nmatrix.so"
 else
@@ -36,7 +36,7 @@ end
 
 require 'nmatrix/nmatrix.rb'
 require 'nmatrix/version.rb'
-require 'nmatrix/nvector.rb'
+#require 'nmatrix/nvector.rb'
 require 'nmatrix/blas.rb'
 require 'nmatrix/monkeys'
 require "nmatrix/shortcuts.rb"

data/lib/nmatrix/blas.rb

@@ -180,7 +180,7 @@ module NMatrix::BLAS
     #   - +ArgumentError+ -> Need to supply n for non-standard incx, incy values.
     #
     def rot(x, y, c, s, incx = 1, incy = 1, n = nil, in_place=false)
-      raise(ArgumentError, 'Expected dense NVectors as first two arguments.') unless x.is_a?(NMatrix) and y.is_a?(NMatrix) and x.stype == :dense and y.stype == :dense
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless x.is_a?(NMatrix) and y.is_a?(NMatrix) and x.stype == :dense and y.stype == :dense
       raise(ArgumentError, 'NMatrix dtype mismatch.')													unless x.dtype == y.dtype
       raise(ArgumentError, 'Need to supply n for non-standard incx, incy values') if n.nil? && incx != 1 && incx != -1 && incy != 1 && incy != -1
 
@@ -228,7 +228,7 @@ module NMatrix::BLAS
     #   - +ArgumentError+ -> Expected dense NVector of size 2
     #
     def rotg(ab)
-      raise(ArgumentError, "Expected dense NVector of size 2") unless ab.is_a?(NVector) && ab.size == 2
+      raise(ArgumentError, "Expected dense NMatrix of shape [2,1] or [1,2]") unless ab.is_a?(NMatrix) && ab.stype == :dense && ab.size == 2
 
       ::NMatrix::BLAS.cblas_rotg(ab)
     end
@@ -252,7 +252,7 @@ module NMatrix::BLAS
     #
     def asum(x, incx = 1, n = nil)
       n ||= x.size / incx
-      raise(ArgumentError, "Expected dense NVector (or NMatrix on rare occasions) for arg 0") unless x.is_a?(NMatrix)
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") unless x.is_a?(NMatrix)
       raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
       ::NMatrix::BLAS.cblas_asum(n, x, incx)
     end
@@ -275,7 +275,7 @@ module NMatrix::BLAS
     #
     def nrm2(x, incx = 1, n = nil)
       n ||= x.size / incx
-      raise(ArgumentError, "Expected dense NVector (or NMatrix on rare occasions) for arg 0") unless x.is_a?(NMatrix)
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") unless x.is_a?(NMatrix)
       raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
       ::NMatrix::BLAS.cblas_nrm2(n, x, incx)
     end

data/lib/nmatrix/enumerate.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 - 2013, Ruby Science Foundation
+# NMatrix is Copyright (c) 2013, 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
+  #
+  def map(&bl)
+    return enum_for(:map) unless block_given?
+    cp = self.dup
+    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?
+    self.each_stored_with_indices do |e, *i|
+      self[*i] = (yield e)
+    end
+    self
+  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
+    new_shape[dimen] = 1
+
+    first_as_acc = false
+
+    if initial then
+      acc = NMatrix.new(new_shape, initial, dtype || self.dtype)
+    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/lapack.rb

@@ -120,6 +120,59 @@ class NMatrix
         clapack_potrs(order, uplo, n, nrhs, a, lda, b, ldb)
       end
 
+      #
+      # call-seq:
+      #     gesvd(matrix, type)
+      # 
+      #
+      # * *Arguments* :
+      #   - +matrix+ -> matrix for which to compute the singular values ##TODO make this a self
+      #   - +type+ -> :all_values, :both, :left, :right, :left_matrix, :right_matrix, :overwrite_right, :overwrite_left, :none , or signifying what combination of singular values and matrices are desired in your output.
+      # * *Returns* :
+      #   - Array with the result values in an array
+      # * *Raises* :
+      #   - +ArgumentError+ -> Expected dense NMatrix as first argument.
+      #
+      def gesvd(matrix, type = :both)
+        raise ArgumentError, 'Expected dense NMatrix as first argument.' unless matrix.is_a?(NMatrix) and matrix.stype == :dense
+        #define jobu, jobvt
+        jobu, jobvt = :none, :none
+        case type
+        when :both
+         jobu, jobvt = :all, :all
+        when :arrays
+          jobu, jobvt = :return, :return
+        when :left
+          jobu = :return
+        when :right
+          jobvt = :return
+        end
+        
+        # Build up the u and vt matrices
+        m, n = matrix.shape
+        dtype = matrix.dtype
+        s_matrix = NMatrix.new([1,matrix.shape.min], dtype)
+        u_matrix = NMatrix.new([m,m], dtype)
+        v_matrix = NMatrix.new([n,n], dtype)
+        # test this
+        s = gesvd(type, matrix, s_matrix, u_matrix, v_matrix)
+
+        # what should this return?
+        [s_matrix, u_matrix, v_matrix]
+      end # #svd
+
+      #     laswp(matrix, ipiv) -> NMatrix
+      #
+      # Permute the columns of a matrix (in-place) according to the Array +ipiv+.
+      #
+      def laswp(matrix, ipiv)
+        raise(ArgumentError, "expected NMatrix for argument 0") unless matrix.is_a?(NMatrix)
+        raise(StorageTypeError, "LAPACK functions only work on :dense NMatrix instances") unless matrix.stype == :dense
+        raise(ArgumentError, "expected Array ipiv to have no more entries than NMatrix a has columns") if ipiv.size > matrix.shape[1]
+
+        clapack_laswp(matrix.shape[0], matrix, matrix.shape[1], 0, ipiv.size-1, ipiv, 1)
+      end
+
     end
   end
-end
+end

data/lib/nmatrix/math.rb

@@ -0,0 +1,462 @@
+#--
+# = 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 - 2013, Ruby Science Foundation
+# NMatrix is Copyright (c) 2013, 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
+#
+# == math.rb
+#
+# Math functionality for NMatrix, along with any NMatrix instance
+# methods that correspond to ATLAS/BLAS/LAPACK functions (e.g.,
+# laswp).
+#++
+
+class NMatrix
+  #
+  # call-seq:
+  #     invert! -> NMatrix
+  #
+  # Use LAPACK to calculate the inverse of the matrix (in-place). Only works on
+  # dense matrices.
+  #
+  # Note: If you don't have LAPACK, e.g., on a Mac, this may not work yet.
+  #
+  def invert!
+    # Get the pivot array; factor the matrix
+    pivot = self.getrf!
+
+    # Now calculate the inverse using the pivot array
+    NMatrix::LAPACK::clapack_getri(:row, self.shape[1], self, self.shape[1], pivot)
+
+    self
+  end
+
+  #
+  # call-seq:
+  #     invert -> NMatrix
+  #
+  # Make a copy of the matrix, then invert it (requires LAPACK).
+  #
+  # * *Returns* :
+  #   - A dense NMatrix.
+  #
+  def invert
+    self.cast(:dense, self.dtype).invert!
+  end
+  alias :inverse :invert
+
+  #
+  # call-seq:
+  #     getrf! -> NMatrix
+  #
+  # LU factorization of a general M-by-N matrix +A+ using partial pivoting with
+  # row interchanges. Only works in dense matrices.
+  #
+  # * *Returns* :
+  #   - The IPIV vector. The L and U matrices are stored in A.
+  # * *Raises* :
+  #   - +StorageTypeError+ -> ATLAS functions only work on dense matrices.
+  #
+  def getrf!
+    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.stype == :dense
+    NMatrix::LAPACK::clapack_getrf(:row, self.shape[0], self.shape[1], self, self.shape[1])
+  end
+
+  #
+  # call-seq:
+  #     factorize_lu -> ...
+  #
+  # LU factorization of a matrix.
+  #
+  # FIXME: For some reason, getrf seems to require that the matrix be transposed first -- and then you have to transpose the
+  # FIXME: result again. Ideally, this would be an in-place factorize instead, and would be called nm_factorize_lu_bang.
+  #
+  def factorize_lu
+    raise(NotImplementedError, "only implemented for dense storage") unless self.stype == :dense
+    raise(NotImplementedError, "matrix is not 2-dimensional") unless self.dimensions == 2
+
+    t = self.transpose
+    NMatrix::LAPACK::clapack_getrf(:row, t.shape[0], t.shape[1], t, t.shape[1])
+    t.transpose
+  end
+
+  def alloc_svd_result
+    [
+      NMatrix.new(:dense, self.shape[0], self.dtype),
+      NMatrix.new(:dense, [self.shape[0],1], self.dtype),
+      NMatrix.new(:dense, self.shape[1], self.dtype)
+    ]
+  end
+
+  #
+  # call-seq:
+  #     gesvd -> [u, sigma, v_transpose]
+  #     gesvd -> [u, sigma, v_conjugate_transpose] # complex
+  #
+  # Compute the singular value decomposition of a matrix using LAPACK's GESVD function.
+  #
+  # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
+  # requires.
+  #
+  def gesvd(workspace_size=1)
+    result = alloc_svd_result
+    NMatrix::LAPACK::lapack_gesvd(:a, :a, self.shape[0], self.shape[1], self, self.shape[0], result[1], result[0], self.shape[0], result[2], self.shape[1], workspace_size)
+    result
+  end
+
+
+  #
+  # call-seq:
+  #     gesdd -> [u, sigma, v_transpose]
+  #     gesdd -> [u, sigma, v_conjugate_transpose] # complex
+  #
+  # Compute the singular value decomposition of a matrix using LAPACK's GESDD function. This uses a divide-and-conquer
+  # strategy. See also #gesvd.
+  #
+  # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
+  # requires.
+  #
+  def gesdd(workspace_size=1)
+    result = alloc_svd_result
+    NMatrix::LAPACK::lapack_gesvd(:a, :a, self.shape[0], self.shape[1], self, self.shape[0], result[1], result[0], self.shape[0], result[2], self.shape[1], workspace_size)
+    result
+  end
+
+  #
+  # call-seq:
+  #     laswp!(ary) -> NMatrix
+  #
+  # In-place permute the columns of a dense matrix using LASWP according to the order given in an Array +ary+.
+  # Not yet implemented for yale or list.
+  def laswp!(ary)
+    NMatrix::LAPACK::laswp(self, ary)
+  end
+
+  #
+  # call-seq:
+  #     laswp(ary) -> NMatrix
+  #
+  # Permute the columns of a dense matrix using LASWP according to the order given in an Array +ary+.
+  # Not yet implemented for yale or list.
+  def laswp(ary)
+    self.clone.laswp!(ary)
+  end
+
+  #
+  # call-seq:
+  #     det -> determinant
+  #
+  # Calculate the determinant by way of LU decomposition. This is accomplished
+  # using clapack_getrf, and then by summing the diagonal elements. There is a
+  # risk of underflow/overflow.
+  #
+  # There are probably also more efficient ways to calculate the determinant.
+  # This method requires making a copy of the matrix, since clapack_getrf
+  # modifies its input.
+  #
+  # For smaller matrices, you may be able to use +#det_exact+.
+  #
+  # This function is guaranteed to return the same type of data in the matrix
+  # upon which it is called.
+  # In other words, if you call it on a rational matrix, you'll get a rational
+  # number back.
+  #
+  # Integer matrices are converted to rational matrices for the purposes of
+  # performing the calculation, as xGETRF can't work on integer matrices.
+  #
+  # * *Returns* :
+  #   - The determinant of the matrix. It's the same type as the matrix's dtype.
+  # * *Raises* :
+  #   - +NotImplementedError+ -> Must be used in 2D matrices.
+  #
+  def det
+    raise(NotImplementedError, "determinant can be calculated only for 2D matrices") unless self.dim == 2
+
+    # Cast to a dtype for which getrf is implemented
+    new_dtype = [:byte,:int8,:int16,:int32,:int64].include?(self.dtype) ? :rational128 : self.dtype
+    copy = self.cast(:dense, new_dtype)
+
+    # Need to know the number of permutations. We'll add up the diagonals of
+    # the factorized matrix.
+    pivot = copy.getrf!
+
+    prod = pivot.size % 2 == 1 ? -1 : 1 # odd permutations => negative
+    [shape[0],shape[1]].min.times do |i|
+      prod *= copy[i,i]
+    end
+
+    # Convert back to an integer if necessary
+    new_dtype != self.dtype ? prod.to_i : prod
+  end
+
+  #
+  # call-seq:
+  #     complex_conjugate -> NMatrix
+  #     complex_conjugate(new_stype) -> NMatrix
+  #
+  # Get the complex conjugate of this matrix. See also complex_conjugate! for
+  # an in-place operation (provided the dtype is already +:complex64+ or
+  # +:complex128+).
+  #
+  # Doesn't work on list matrices, but you can optionally pass in the stype you
+  # want to cast to if you're dealing with a list matrix.
+  #
+  # * *Arguments* :
+  #   - +new_stype+ -> stype for the new matrix.
+  # * *Returns* :
+  #   - If the original NMatrix isn't complex, the result is a +:complex128+ NMatrix. Otherwise, it's the original dtype.
+  #
+  def complex_conjugate(new_stype = self.stype)
+    self.cast(new_stype, NMatrix::upcast(dtype, :complex64)).complex_conjugate!
+  end
+
+  #
+  # call-seq:
+  #     conjugate_transpose -> NMatrix
+  #
+  # Calculate the conjugate transpose of a matrix. If your dtype is already
+  # complex, this should only require one copy (for the transpose).
+  #
+  # * *Returns* :
+  #   - The conjugate transpose of the matrix as a copy.
+  #
+  def conjugate_transpose
+    self.transpose.complex_conjugate!
+  end
+
+  #
+  # call-seq:
+  #     hermitian? -> Boolean
+  #
+  # A hermitian matrix is a complex square matrix that is equal to its
+  # conjugate transpose. (http://en.wikipedia.org/wiki/Hermitian_matrix)
+  #
+  # * *Returns* :
+  #   - True if +self+ is a hermitian matrix, nil otherwise.
+  #
+  def hermitian?
+    return false if self.dim != 2 or self.shape[0] != self.shape[1]
+
+    if [:complex64, :complex128].include?(self.dtype)
+      # TODO: Write much faster Hermitian test in C
+      self.eql?(self.conjugate_transpose)
+    else
+      symmetric?
+    end
+  end
+
+  ##
+  # call-seq:
+  #   mean() -> NMatrix
+  #   mean(dimen) -> NMatrix
+  #
+  # Calculates the mean along the specified dimension.
+  #
+  # This will force integer types to float64 dtype.
+  #
+  # @see #inject_rank
+  #
+  def mean(dimen=0)
+    reduce_dtype = nil
+    if integer_dtype? then
+      reduce_dtype = :float64
+    end
+    inject_rank(dimen, 0.0, reduce_dtype) do |mean, sub_mat|
+      mean + sub_mat/shape[dimen]
+    end
+  end
+
+  ##
+  # call-seq:
+  #   sum() -> NMatrix
+  #   sum(dimen) -> NMatrix
+  #
+  # Calculates the sum along the specified dimension.
+  #
+  # @see #inject_rank
+  def sum(dimen=0)
+    inject_rank(dimen, 0.0) do |sum, sub_mat|
+      sum + sub_mat
+    end
+  end
+
+
+  ##
+  # call-seq:
+  #   min() -> NMatrix
+  #   min(dimen) -> NMatrix
+  #
+  # Calculates the minimum along the specified dimension.
+  #
+  # @see #inject_rank
+  #
+  def min(dimen=0)
+    inject_rank(dimen) do |min, sub_mat|
+      if min.is_a? NMatrix then
+        min * (min <= sub_mat).cast(self.stype, self.dtype) + ((min)*0.0 + (min > sub_mat).cast(self.stype, self.dtype)) * sub_mat
+      else
+        min <= sub_mat ? min : sub_mat
+      end
+    end
+  end
+
+  ##
+  # call-seq:
+  #   max() -> NMatrix
+  #   max(dimen) -> NMatrix
+  #
+  # Calculates the maximum along the specified dimension.
+  #
+  # @see #inject_rank
+  #
+  def max(dimen=0)
+    inject_rank(dimen) do |max, sub_mat|
+      if max.is_a? NMatrix then
+        max * (max >= sub_mat).cast(self.stype, self.dtype) + ((max)*0.0 + (max < sub_mat).cast(self.stype, self.dtype)) * sub_mat
+      else
+        max >= sub_mat ? max : sub_mat
+      end
+    end
+  end
+
+
+  ##
+  # call-seq:
+  #   variance() -> NMatrix
+  #   variance(dimen) -> NMatrix
+  #
+  # Calculates the sample variance along the specified dimension.
+  #
+  # This will force integer types to float64 dtype.
+  #
+  # @see #inject_rank
+  #
+  def variance(dimen=0)
+    reduce_dtype = nil
+    if integer_dtype? then
+      reduce_dtype = :float64
+    end
+    m = mean(dimen)
+    inject_rank(dimen, 0.0, reduce_dtype) do |var, sub_mat|
+      var + (m - sub_mat)*(m - sub_mat)/(shape[dimen]-1)
+    end
+  end
+
+  ##
+  # call-seq:
+  #   std() -> NMatrix
+  #   std(dimen) -> NMatrix
+  #
+  #
+  # Calculates the sample standard deviation along the specified dimension.
+  #
+  # This will force integer types to float64 dtype.
+  #
+  # @see #inject_rank
+  #
+  def std(dimen=0)
+    variance(dimen).map! { |e| Math.sqrt(e) }
+  end
+
+
+  #
+  # call-seq:
+  #     abs_dtype -> Symbol
+  #
+  # Returns the dtype of the result of a call to #abs. In most cases, this is the same as dtype; it should only differ
+  # for :complex64 (where it's :float32) and :complex128 (:float64).
+  def abs_dtype
+    if self.dtype == :complex64
+      :float32
+    elsif self.dtype == :complex128
+      :float64
+    else
+      self.dtype
+    end
+  end
+
+
+  #
+  # call-seq:
+  #     abs -> NMatrix
+  #
+  # Maps all values in a matrix to their absolute values.
+  def abs
+    if stype == :dense
+      self.__dense_map__ { |v| v.abs }
+    elsif stype == :list
+      # FIXME: Need __list_map_stored__, but this will do for now.
+      self.__list_map_merged_stored__(nil, nil) { |v,dummy| v.abs }
+    else
+      self.__yale_map_stored__ { |v| v.abs }
+    end.cast(self.stype, abs_dtype)
+  end
+
+  alias :permute_columns  :laswp
+  alias :permute_columns! :laswp!
+
+protected
+  # Define the element-wise operations for lists. Note that the __list_map_merged_stored__ iterator returns a Ruby Object
+  # matrix, which we then cast back to the appropriate type. If you don't want that, you can redefine these functions in
+  # your own code.
+  {add: :+, sub: :-, mul: :*, div: :/, pow: :**, mod: :%}.each_pair do |ewop, op|
+    define_method("__list_elementwise_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, rhs.dtype))
+    end
+    define_method("__dense_elementwise_#{ewop}__") do |rhs|
+      self.__dense_map_pair__(rhs) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, rhs.dtype))
+    end
+    define_method("__yale_elementwise_#{ewop}__") do |rhs|
+      self.__yale_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, rhs.dtype))
+    end
+    define_method("__list_scalar_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }.cast(stype, NMatrix.upcast(dtype, NMatrix.min_dtype(rhs)))
+    end
+    define_method("__yale_scalar_#{ewop}__") do |rhs|
+      self.__yale_map_stored__ { |l| l.send(op,rhs) }.cast(stype, NMatrix.upcast(dtype, NMatrix.min_dtype(rhs)))
+    end
+    define_method("__dense_scalar_#{ewop}__") do |rhs|
+      self.__dense_map__ { |l| l.send(op,rhs) }.cast(stype, NMatrix.upcast(dtype, NMatrix.min_dtype(rhs)))
+    end
+  end
+
+  # Equality operators do not involve a cast. We want to get back matrices of TrueClass and FalseClass.
+  {eqeq: :==, neq: :!=, lt: :<, gt: :>, leq: :<=, geq: :>=}.each_pair do |ewop, op|
+    define_method("__list_elementwise_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }
+    end
+    define_method("__dense_elementwise_#{ewop}__") do |rhs|
+      self.__dense_map_pair__(rhs) { |l,r| l.send(op,r) }
+    end
+    define_method("__yale_elementwise_#{ewop}__") do |rhs|
+      self.__yale_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }
+    end
+
+    define_method("__list_scalar_#{ewop}__") do |rhs|
+      self.__list_map_merged_stored__(rhs, nil) { |l,r| l.send(op,r) }
+    end
+    define_method("__yale_scalar_#{ewop}__") do |rhs|
+      self.__yale_map_stored__ { |l| l.send(op,rhs) }
+    end
+    define_method("__dense_scalar_#{ewop}__") do |rhs|
+      self.__dense_map__ { |l| l.send(op,rhs) }
+    end
+  end
+end