nmatrix 0.0.9 → 0.1.0.rc1

data/lib/nmatrix/io/mat_reader.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+# 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.
 #

data/lib/nmatrix/lapack.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-# NMatrix is Copyright (c) 2013, Ruby Science Foundation
+# 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.
 #
@@ -64,16 +64,16 @@ class NMatrix
       #   - +nrhs+ ->
       #   - +a+ ->
       #   - +lda+ ->
-      #   - +ipiv+ ->
       #   - +b+ ->
       #   - +ldb+ ->
+      #   - +ipiv+ -> A pivot array (if nil, one will be generated with +clapack_getrf+)
       # * *Returns* :
       #   -
       # * *Raises* :
       #   - ++ ->
       #
-      def clapack_gesv(order, n, nrhs, a, lda, ipiv, b, ldb)
-        clapack_getrf(order, n, n, a, lda, ipiv)
+      def clapack_gesv(order, n, nrhs, a, lda, b, ldb, ipiv=nil)
+        ipiv ||= clapack_getrf(order, n, n, a, lda)
         clapack_getrs(order, :no_transpose, n, nrhs, a, lda, ipiv, b, ldb)
       end
 
@@ -120,47 +120,6 @@ 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: dtype)
-        u_matrix = NMatrix.new([m,m], dtype: dtype)
-        v_matrix = NMatrix.new([n,n], dtype: 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+.
@@ -173,6 +132,47 @@ class NMatrix
         clapack_laswp(matrix.shape[0], matrix, matrix.shape[1], 0, ipiv.size-1, ipiv, 1)
       end
 
+      def alloc_svd_result(matrix)
+        [
+          NMatrix.new(matrix.shape[0], dtype: matrix.dtype),
+          NMatrix.new([matrix.shape[0],1], dtype: matrix.dtype),
+          NMatrix.new(matrix.shape[1], dtype: matrix.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(matrix, workspace_size=1)
+        result = alloc_svd_result(matrix)
+        NMatrix::LAPACK::lapack_gesvd(:a, :a, matrix.shape[0], matrix.shape[1], matrix, matrix.shape[0], result[1], result[0], matrix.shape[0], result[2], matrix.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(matrix, workspace_size=100000)
+        result = alloc_svd_result(matrix)
+        NMatrix::LAPACK::lapack_gesdd(:a, matrix.shape[0], matrix.shape[1], matrix, matrix.shape[0], result[1], result[0], matrix.shape[0], result[2], matrix.shape[1], workspace_size)
+        result
+      end
+
     end
   end
 end

data/lib/nmatrix/math.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-# NMatrix is Copyright (c) 2013, Ruby Science Foundation
+# 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.
 #
@@ -29,6 +29,13 @@
 #++
 
 class NMatrix
+
+  module NMMath
+    METHODS_ARITY_2 = [:atan2, :ldexp, :hypot]
+    METHODS_ARITY_1 = [:cos, :sin, :tan, :acos, :asin, :atan, :cosh, :sinh, :tanh, :acosh,
+      :asinh, :atanh, :exp, :log2, :log10, :sqrt, :cbrt, :erf, :erfc, :gamma]
+  end
+
   #
   # call-seq:
   #     invert! -> NMatrix
@@ -75,10 +82,66 @@ class NMatrix
   #   - +StorageTypeError+ -> ATLAS functions only work on dense matrices.
   #
   def getrf!
-    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.stype == :dense
+    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.dense?
     NMatrix::LAPACK::clapack_getrf(:row, self.shape[0], self.shape[1], self, self.shape[1])
   end
 
+
+  #
+  # call-seq:
+  #     getrf -> NMatrix
+  #
+  # In-place version of #getrf!. Returns the new matrix, which contains L and U matrices.
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> ATLAS functions only work on dense matrices.
+  #
+  def getrf
+    a = self.clone
+    a.getrf!
+    return a
+  end
+
+
+  #
+  # call-seq:
+  #     potrf!(upper_or_lower) -> NMatrix
+  #
+  # Cholesky factorization of a symmetric positive-definite matrix -- or, if complex,
+  # a Hermitian positive-definite matrix +A+. This uses the ATLAS function clapack_potrf,
+  # so the result will be written in either the upper or lower triangular portion of the
+  # matrix upon which it is called.
+  #
+  # * *Returns* :
+  #   the triangular portion specified by the parameter
+  # * *Raises* :
+  #   - +StorageTypeError+ -> ATLAS functions only work on dense matrices.
+  #
+  def potrf!(which)
+    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.dense?
+    # FIXME: Surely there's an easy way to calculate one of these from the other. Do we really need to run twice?
+    NMatrix::LAPACK::clapack_potrf(:row, which, self.shape[0], self, self.shape[1])
+  end
+
+  def potrf_upper!
+    potrf! :upper
+  end
+
+  def potrf_lower!
+    potrf! :lower
+  end
+
+
+  #
+  # call-seq:
+  #     factorize_cholesky -> ...
+  #
+  # Cholesky factorization of a matrix.
+  def factorize_cholesky
+    [self.clone.potrf_upper!.triu!,
+    self.clone.potrf_lower!.tril!]
+  end
+
   #
   # call-seq:
   #     factorize_lu -> ...
@@ -97,12 +160,19 @@ class NMatrix
     t.transpose
   end
 
-  def alloc_svd_result
-    [
-      NMatrix.new(self.shape[0], dtype: self.dtype),
-      NMatrix.new([self.shape[0],1], dtype: self.dtype),
-      NMatrix.new(self.shape[1], dtype: self.dtype)
-    ]
+  #
+  # 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. 
+  # This is destructive, modifying the source NMatrix.  See also #gesdd.
+  #
+  # Optionally accepts a +workspace_size+ parameter, which will be honored only if it is larger than what LAPACK
+  # requires.
+  #
+  def gesvd!(workspace_size=1)
+    NMatrix::LAPACK::gesvd(self, workspace_size)
   end
 
   #
@@ -116,12 +186,26 @@ class NMatrix
   # 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
+    self.clone.gesvd!(workspace_size)
   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. This is destructive, modifying the source NMatrix.  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)
+    NMatrix::LAPACK::gesdd(self, workspace_size)
+  end
+
   #
   # call-seq:
   #     gesdd -> [u, sigma, v_transpose]
@@ -134,11 +218,8 @@ class NMatrix
   # 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
+    self.clone.gesdd!(workspace_size)
   end
-
   #
   # call-seq:
   #     laswp!(ary) -> NMatrix
@@ -279,8 +360,8 @@ class NMatrix
       reduce_dtype = :float64
     end
     inject_rank(dimen, 0.0, reduce_dtype) do |mean, sub_mat|
-      mean + sub_mat/shape[dimen]
-    end
+      mean + sub_mat
+    end / shape[dimen]
   end
 
   ##
@@ -372,7 +453,7 @@ class NMatrix
   # @see #inject_rank
   #
   def std(dimen=0)
-    variance(dimen).map! { |e| Math.sqrt(e) }
+    variance(dimen).sqrt
   end
 
 
@@ -409,6 +490,38 @@ class NMatrix
     end.cast(self.stype, abs_dtype)
   end
 
+
+  #
+  # call-seq:
+  #     absolute_sum -> Numeric
+  #
+  # == Arguments
+  #   - +incx+ -> the skip size (defaults to 1, no skip)
+  #   - +n+ -> the number of elements to include
+  #
+  # Return the sum of the contents of the vector. This is the BLAS asum routine.
+  def asum incx=1, n=nil
+    return method_missing(:asum, incx, n) unless vector?
+    NMatrix::BLAS::asum(self, incx, self.size / incx)
+  end
+  alias :absolute_sum :asum
+
+  #
+  # call-seq:
+  #     norm2 -> Numeric
+  #
+  # == Arguments
+  #   - +incx+ -> the skip size (defaults to 1, no skip)
+  #   - +n+ -> the number of elements to include
+  #
+  # Return the 2-norm of the vector. This is the BLAS nrm2 routine.
+  def nrm2 incx=1, n=nil
+    return method_missing(:nrm2, incx, n) unless vector?
+    NMatrix::BLAS::nrm2(self, incx, self.size / incx)
+  end
+  alias :norm2 :nrm2
+
+
   alias :permute_columns  :laswp
   alias :permute_columns! :laswp!
 
@@ -437,6 +550,86 @@ protected
     end
   end
 
+  # These don't actually take an argument -- they're called reverse-polish style on the matrix.
+  # This group always gets casted to float64.
+  [:log2, :log10, :sqrt, :sin, :cos, :tan, :acos, :asin, :atan, :cosh, :sinh, :tanh, :acosh, :asinh, :atanh, :exp, :erf, :erfc, :gamma, :cbrt].each do |ewop|
+    define_method("__list_unary_#{ewop}__") do
+      self.__list_map_stored__(nil) { |l| Math.send(ewop, l) }.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+    define_method("__yale_unary_#{ewop}__") do
+      self.__yale_map_stored__ { |l| Math.send(ewop, l) }.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+    define_method("__dense_unary_#{ewop}__") do
+      self.__dense_map__ { |l| Math.send(ewop, l) }.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+  end
+
+  # log takes an optional single argument, the base.  Default to natural log.
+  def __list_unary_log__(base)
+    self.__list_map_stored__(nil) { |l| Math.log(l, base) }.cast(stype, NMatrix.upcast(dtype, :float64))
+  end
+
+  def __yale_unary_log__(base)
+    self.__yale_map_stored__ { |l| Math.log(l, base) }.cast(stype, NMatrix.upcast(dtype, :float64))
+  end
+
+  def __dense_unary_log__(base)
+    self.__dense_map__ { |l| Math.log(l, base) }.cast(stype, NMatrix.upcast(dtype, :float64))
+  end
+
+  # These take two arguments. One might be a matrix, and one might be a scalar.
+  # See also monkeys.rb, which contains Math module patches to let the first
+  # arg be a scalar
+  [:atan2, :ldexp, :hypot].each do |ewop|
+    define_method("__list_elementwise_#{ewop}__") do |rhs,order|
+      if order then
+        self.__list_map_merged_stored__(rhs, nil) { |r,l| Math.send(ewop,l,r) }
+      else
+        self.__list_map_merged_stored__(rhs, nil) { |l,r| Math.send(ewop,l,r) }
+      end.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+
+    define_method("__dense_elementwise_#{ewop}__") do |rhs, order|
+      if order then
+        self.__dense_map_pair__(rhs) { |r,l| Math.send(ewop,l,r) }
+      else
+        self.__dense_map_pair__(rhs) { |l,r| Math.send(ewop,l,r) }
+      end.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+
+    define_method("__yale_elementwise_#{ewop}__") do |rhs, order|
+      if order then
+        self.__yale_map_merged_stored__(rhs, nil) { |r,l| Math.send(ewop,l,r) }
+      else
+        self.__yale_map_merged_stored__(rhs, nil) { |l,r| Math.send(ewop,l,r) }
+      end.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+
+    define_method("__list_scalar_#{ewop}__") do |rhs,order|
+      if order then
+        self.__list_map_stored__(nil) { |l| Math.send(ewop, rhs, l) }
+      else
+        self.__list_map_stored__(nil) { |l| Math.send(ewop, l, rhs) }
+      end.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+
+    define_method("__yale_scalar_#{ewop}__") do |rhs,order|
+      if order then
+        self.__yale_map_stored__ { |l| Math.send(ewop, rhs, l) }
+      else
+        self.__yale_map_stored__ { |l| Math.send(ewop, l, rhs) }
+      end.cast(stype, NMatrix.upcast(dtype, :float64))
+    end
+
+    define_method("__dense_scalar_#{ewop}__") do |rhs,order|
+      if order
+        self.__dense_map__ { |l| Math.send(ewop, rhs, l) }
+      else
+        self.__dense_map__ { |l| Math.send(ewop, l, rhs) }
+      end.cast(stype, NMatrix.upcast(dtype, :float64))
+    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|
@@ -459,4 +652,4 @@ protected
       self.__dense_map__ { |l| l.send(op,rhs) }
     end
   end
-end
+end

data/lib/nmatrix/monkeys.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-# NMatrix is Copyright (c) 2013, Ruby Science Foundation
+# 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.
 #
@@ -26,6 +26,8 @@
 # Ruby core extensions for NMatrix.
 #++
 
+require 'nmatrix/math'
+
 #######################
 # Classes and Modules #
 #######################
@@ -60,3 +62,23 @@ class Object #:nodoc:
     value
   end
 end
+
+
+module Math
+  class << self
+    NMatrix::NMMath::METHODS_ARITY_2.each do |meth|
+      define_method "nm_#{meth}" do |arg0, arg1|
+        if arg0.is_a? NMatrix then
+          arg0.send(meth, arg1)
+        elsif arg1.is_a? NMatrix then
+          arg1.send(meth, arg0, true)
+        else
+          self.send("old_#{meth}".to_sym, arg0, arg1)
+        end
+      end
+      alias_method "old_#{meth}".to_sym, meth
+      alias_method meth, "nm_#{meth}".to_sym
+    end
+  end
+end
+