nmatrix 0.2.0 → 0.2.1

data/ext/nmatrix/util/sl_list.cpp

@@ -119,10 +119,10 @@ void mark(LIST* list, size_t recursions) {
     next = curr->next;
     
     if (recursions == 0) {
-    	rb_gc_mark(*((VALUE*)(curr->val)));
-    	
+      rb_gc_mark(*((VALUE*)(curr->val)));
+      
     } else {
-    	mark((LIST*)curr->val, recursions - 1);
+      mark((LIST*)curr->val, recursions - 1);
     }
     
     curr = next;
@@ -174,8 +174,8 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
   NODE *ins;
 
   if (list->first == NULL) {
-  	// List is empty
-  	
+    // List is empty
+    
     //if (!(ins = malloc(sizeof(NODE)))) return NULL;
     ins = NM_ALLOC(NODE);
     ins->next             = NULL;
@@ -186,8 +186,8 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
     return ins;
 
   } else if (key < list->first->key) {
-  	// Goes at the beginning of the list
-  	
+    // Goes at the beginning of the list
+    
     //if (!(ins = malloc(sizeof(NODE)))) return NULL;
     ins = NM_ALLOC(NODE);
     ins->next             = list->first;
@@ -214,7 +214,7 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
     return ins;
 
   } else {
-  	return insert_after(ins, key, val);
+    return insert_after(ins, key, val);
   }
 }
 
@@ -305,7 +305,7 @@ void* remove_by_key(LIST* list, size_t key) {
   void* val;
 
   if (!list->first || list->first->key > key) { // empty list or def. not present
-  	return NULL;
+    return NULL;
   }
 
   if (list->first->key == key) {
@@ -320,7 +320,7 @@ void* remove_by_key(LIST* list, size_t key) {
 
   f = find_preceding_from_node(list->first, key);
   if (!f || !f->next) { // not found, end of list
-  	return NULL;
+    return NULL;
   }
 
   if (f->next->key == key) {
@@ -411,15 +411,15 @@ bool remove_recursive(LIST* list, const size_t* coords, const size_t* offsets, c
 NODE* find(LIST* list, size_t key) {
   NODE* f;
   if (!list->first) {
-  	// empty list -- does not exist
-  	return NULL;
+    // empty list -- does not exist
+    return NULL;
   }
 
   // see if we can find it.
   f = find_nearest_from(list->first, key);
   
   if (!f || f->key == key) {
-  	return f;
+    return f;
   }
   
   return NULL;
@@ -458,10 +458,10 @@ NODE* find_preceding_from_node(NODE* prev, size_t key) {
   NODE* curr = prev->next;
 
   if (!curr || key <= curr->key) {
-  	return prev;
-  	
+    return prev;
+    
   } else {
-  	return find_preceding_from_node(curr, key);
+    return find_preceding_from_node(curr, key);
   }
 }
 
@@ -491,19 +491,19 @@ NODE* find_nearest_from(NODE* prev, size_t key) {
   NODE* f;
 
   if (prev && prev->key == key) {
-  	return prev;
+    return prev;
   }
 
   f = find_preceding_from_node(prev, key);
 
   if (!f->next) { // key exceeds final node; return final node.
-  	return f;
-  	
+    return f;
+    
   } else if (key == f->next->key) { // node already present; return location
-  	return f->next;
+    return f->next;
 
   } else {
-  	return f;
+    return f;
   }
 }
 
@@ -528,14 +528,14 @@ void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions) {
       lcurr->key = rcurr->key;
 
       if (recursions == 0) {
-      	// contents is some kind of value
+        // contents is some kind of value
 
         lcurr->val = NM_ALLOC( LDType );
 
         *reinterpret_cast<LDType*>(lcurr->val) = *reinterpret_cast<RDType*>( rcurr->val );
 
       } else {
-      	// contents is a list
+        // contents is a list
 
         lcurr->val = NM_ALLOC( LIST );
 
@@ -547,10 +547,10 @@ void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions) {
       }
 
       if (rcurr->next) {
-      	lcurr->next = NM_ALLOC( NODE );
+        lcurr->next = NM_ALLOC( NODE );
 
       } else {
-      	lcurr->next = NULL;
+        lcurr->next = NULL;
       }
 
       lcurr = lcurr->next;
@@ -608,7 +608,7 @@ extern "C" {
         size_t key = curr->key;
 
         if (recursions == 0) { // content is some kind of value
-          rb_hash_aset(h, INT2FIX(key), rubyobj_from_cval(curr->val, dtype).rval);
+          rb_hash_aset(h, INT2FIX(key), nm::rubyobj_from_cval(curr->val, dtype).rval);
         } else { // content is a list
           rb_hash_aset(h, INT2FIX(key), nm_list_copy_to_hash(reinterpret_cast<const LIST*>(curr->val), dtype, recursions-1, default_value));
         }

data/ext/nmatrix/util/sl_list.h

@@ -33,6 +33,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <type_traits>
 #include <cstdlib>
 
@@ -69,9 +70,9 @@ namespace nm { namespace list {
 // Lifecycle //
 ///////////////
 
-LIST*	create(void);
-void	del(LIST* list, size_t recursions);
-void	mark(LIST* list, size_t recursions);
+LIST*  create(void);
+void  del(LIST* list, size_t recursions);
+void  mark(LIST* list, size_t recursions);
 
 ///////////////
 // Accessors //
@@ -90,25 +91,25 @@ bool node_is_within_slice(NODE* n, size_t coord, size_t len);
 
 template <typename Type>
 inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type val) {
-	Type* val_mem = NM_ALLOC(Type);
-	*val_mem = val;
-	
-	if (node == NULL) {
-		return insert(list, false, key, val_mem);
-		
-	} else {
-		return insert_after(node, key, val_mem);
-	}
+  Type* val_mem = NM_ALLOC(Type);
+  *val_mem = val;
+  
+  if (node == NULL) {
+    return insert(list, false, key, val_mem);
+    
+  } else {
+    return insert_after(node, key, val_mem);
+  }
 }
 
 template <typename Type>
 inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type* ptr) {
-	if (node == NULL) {
-		return insert(list, false, key, ptr);
-		
-	} else {
-		return insert_after(node, key, ptr);
-	}
+  if (node == NULL) {
+    return insert(list, false, key, ptr);
+    
+  } else {
+    return insert_after(node, key, ptr);
+  }
 }
 
 ///////////

data/lib/nmatrix/blas.rb

@@ -71,7 +71,7 @@ module NMatrix::BLAS
     def gemm(a, b, c = nil, alpha = 1.0, beta = 0.0, transpose_a = false, transpose_b = false, m = nil, n = nil, k = nil, lda = nil, ldb = nil, ldc = nil)
       raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and b.is_a?(NMatrix) and a.stype == :dense and b.stype == :dense
       raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless c.nil? or (c.is_a?(NMatrix) and c.stype == :dense)
-      raise(ArgumentError, 'NMatrix dtype mismatch.')													 unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
+      raise(ArgumentError, 'NMatrix dtype mismatch.')              unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
 
       # First, set m, n, and k, which depend on whether we're taking the
       # transpose of a and b.
@@ -93,7 +93,7 @@ module NMatrix::BLAS
         end
 
         n ||= transpose_b ? b.shape[0] : b.shape[1]
-        c		= NMatrix.new([m, n], dtype: a.dtype)
+        c  = NMatrix.new([m, n], dtype: a.dtype)
       end
 
       # I think these are independent of whether or not a transpose occurs.
@@ -143,7 +143,7 @@ module NMatrix::BLAS
     def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0, transpose_a = false, m = nil, n = nil, lda = nil, incx = nil, incy = nil)
       raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and a.stype == :dense and x.stype == :dense
       raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
-      raise(ArgumentError, 'NMatrix dtype mismatch.')													 unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
+      raise(ArgumentError, 'NMatrix dtype mismatch.')              unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
 
       m ||= transpose_a == :transpose ? a.shape[1] : a.shape[0]
       n ||= transpose_a == :transpose ? a.shape[0] : a.shape[1]
@@ -155,9 +155,9 @@ module NMatrix::BLAS
         y = NMatrix.new([m,1], dtype: a.dtype)
       end
 
-      lda		||= a.shape[1]
-      incx	||= 1
-      incy	||= 1
+      lda  ||= a.shape[1]
+      incx ||= 1
+      incy ||= 1
 
       ::NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
 
@@ -188,7 +188,7 @@ module NMatrix::BLAS
     #
     def rot(x, y, c, s, incx = 1, incy = 1, n = nil, in_place=false)
       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, '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
 
       n ||= [x.size/incx.abs, y.size/incy.abs].min

data/lib/nmatrix/io/mat5_reader.rb

@@ -41,8 +41,8 @@ module NMatrix::IO::Matlab
       attr_reader :byte_order
 
       def initialize(stream = nil, byte_order = nil, content_or_bytes = nil)
-        @stream			= stream
-        @byte_order	= byte_order
+        @stream   = stream
+        @byte_order = byte_order
 
         if content_or_bytes.is_a?(String)
           @content = content_or_bytes
@@ -118,9 +118,9 @@ module NMatrix::IO::Matlab
       # See also to_nm, which is responsible for NMatrix instantiation.
       def to_ruby
         case matlab_class
-        when :mxSPARSE	then	return to_nm
-        when :mxCELL		then	return self.cells.collect { |c| c.to_ruby }
-        else									return to_nm
+        when :mxSPARSE then return to_nm
+        when :mxCELL  then return self.cells.collect { |c| c.to_ruby }
+        else         return to_nm
         end
       end
 
@@ -262,8 +262,8 @@ module NMatrix::IO::Matlab
       #
       def to_nm(dtype = nil)
         # Hardest part is figuring out from_dtype, from_index_dtype, and dtype.
-        dtype			||= guess_dtype_from_mdtype
-        from_dtype	= MatReader::MDTYPE_TO_DTYPE[self.real_part.tag.data_type]
+        dtype   ||= guess_dtype_from_mdtype
+        from_dtype = MatReader::MDTYPE_TO_DTYPE[self.real_part.tag.data_type]
 
         # Create the same kind of matrix that MATLAB saved.
         case matlab_class
@@ -297,8 +297,8 @@ module NMatrix::IO::Matlab
         self.dimensions     = dimensions_tag_data.data
 
         begin
-          name_tag_data			= packedio.read([Element, options])
-          self.matlab_name	= name_tag_data.data.is_a?(Array) ? name_tag_data.data.collect { |i| i.chr }.join('') : name_tag_data.data.chr
+          name_tag_data   = packedio.read([Element, options])
+          self.matlab_name = name_tag_data.data.is_a?(Array) ? name_tag_data.data.collect { |i| i.chr }.join('') : name_tag_data.data.chr
 
         rescue ElementDataIOError => e
           STDERR.puts "ERROR: Failure while trying to read Matlab variable name: #{name_tag_data.inspect}"
@@ -325,8 +325,8 @@ module NMatrix::IO::Matlab
             self.row_index    = packedio.read(read_opts)
           end
 
-          self.real_part			= packedio.read(read_opts)
-          self.imaginary_part	= packedio.read(read_opts) if self.complex
+          self.real_part   = packedio.read(read_opts)
+          self.imaginary_part = packedio.read(read_opts) if self.complex
         end
       end
 
@@ -338,8 +338,8 @@ module NMatrix::IO::Matlab
 
     MDTYPE_UNPACK_ARGS =
       MatReader::MDTYPE_UNPACK_ARGS.merge({
-                                            :miCOMPRESSED	=> [Compressed, {}],
-                                            :miMATRIX			=> [MatrixData, {}]
+                                            :miCOMPRESSED => [Compressed, {}],
+                                            :miMATRIX   => [MatrixData, {}]
                                           })
 
     FIRST_TAG_FIELD_POS = 128
@@ -407,26 +407,26 @@ module NMatrix::IO::Matlab
 
       include Packable
 
-      BYTE_ORDER_LENGTH		= 2
-      DESC_LENGTH					= 116
-      DATA_OFFSET_LENGTH	= 8
-      VERSION_LENGTH			= 2
-      BYTE_ORDER_POS			= 126
+      BYTE_ORDER_LENGTH  = 2
+      DESC_LENGTH     = 116
+      DATA_OFFSET_LENGTH = 8
+      VERSION_LENGTH   = 2
+      BYTE_ORDER_POS   = 126
 
       # TODO: TEST WRITE.
       def write_packed(packedio, options)
-        packedio <<	[desc,				{:bytes => DESC_LENGTH				}] <<
-          [data_offset,	{:bytes => DATA_OFFSET_LENGTH	}] <<
-          [version,			{:bytes => VERSION_LENGTH			}] <<
-          [byte_order,	{:bytes => BYTE_ORDER_LENGTH	}]
+        packedio << [desc,    {:bytes => DESC_LENGTH    }] <<
+          [data_offset, {:bytes => DATA_OFFSET_LENGTH }] <<
+          [version,   {:bytes => VERSION_LENGTH   }] <<
+          [byte_order, {:bytes => BYTE_ORDER_LENGTH }]
       end
 
       def read_packed(packedio, options)
         self.desc, self.data_offset, self.version, self.endian = packedio >>
-          [String,	{:bytes => DESC_LENGTH																	}] >>
-          [String,	{:bytes => DATA_OFFSET_LENGTH														}] >>
-          [Integer,	{:bytes => VERSION_LENGTH, :endian => options[:endian]	}] >>
-          [String,	{:bytes => 2																						}]
+          [String, {:bytes => DESC_LENGTH                 }] >>
+          [String, {:bytes => DATA_OFFSET_LENGTH              }] >>
+          [Integer, {:bytes => VERSION_LENGTH, :endian => options[:endian] }] >>
+          [String, {:bytes => 2                      }]
 
         self.desc.strip!
         self.data_offset.strip!
@@ -466,8 +466,8 @@ module NMatrix::IO::Matlab
           # Small data element format
           raise IOError, 'Small data element format indicated, but length is more than 4 bytes!' if upper > 4
 
-          self.bytes					= upper
-          self.raw_data_type	= lower
+          self.bytes     = upper
+          self.raw_data_type = lower
 
         else
           self.bytes = packedio.read([Integer, BYTES_OPTS.merge(options)])
@@ -560,8 +560,8 @@ module NMatrix::IO::Matlab
       def read_packed(packedio, options)
         raise(ArgumentError, 'Missing mandatory option :endian.') unless options.has_key?(:endian)
 
-        self.tag	= packedio.read([Tag,			{:endian => options[:endian]											}])
-        self.data	= packedio.read([String,	{:endian => options[:endian], :bytes => tag.bytes	}])
+        self.tag = packedio.read([Tag,   {:endian => options[:endian]           }])
+        self.data = packedio.read([String, {:endian => options[:endian], :bytes => tag.bytes }])
 
         begin
           ignore_padding(packedio, (tag.bytes + tag.size) % 8) unless [:miMATRIX, :miCOMPRESSED].include?(tag.data_type)

data/lib/nmatrix/math.rb

@@ -258,36 +258,92 @@ class NMatrix
 
   # Solve the matrix equation AX = B, where A is +self+, B is the first
   # argument, and X is returned. A must be a nxn square matrix, while B must be
-  # nxm. Only works with dense
-  # matrices and non-integer, non-object data types.
+  # nxm. Only works with dense matrices and non-integer, non-object data types.
   # 
+  # == Arguments
+  #
+  # * +b+ - the right hand side
+  #
+  # == Options
+  #
+  # * +form+ - Signifies the form of the matrix A in the linear system AX=B.
+  #   If not set then it defaults to +:general+, which uses an LU solver. 
+  #   Other possible values are +:lower_tri+, +:upper_tri+ and +:pos_def+ (alternatively,
+  #   non-abbreviated symbols +:lower_triangular+, +:upper_triangular+, 
+  #   and +:positive_definite+ can be used. 
+  #   If +:lower_tri+ or +:upper_tri+ is set, then a specialized linear solver for linear 
+  #   systems AX=B with a lower or upper triangular matrix A is used. If +:pos_def+ is chosen, 
+  #   then the linear system is solved via the Cholesky factorization.
+  #   Note that when +:lower_tri+ or +:upper_tri+ is used, then the algorithm just assumes that
+  #   all entries in the lower/upper triangle of the matrix are zeros without checking (which
+  #   can be useful in certain applications).
+  #     
+  #
   # == Usage
   # 
   #   a = NMatrix.new [2,2], [3,1,1,2], dtype: dtype
   #   b = NMatrix.new [2,1], [9,8], dtype: dtype
   #   a.solve(b)
-  def solve b
+  #
+  #   # solve an upper triangular linear system more efficiently:
+  #   require 'benchmark'
+  #   require 'nmatrix/lapacke'
+  #   rand_mat = NMatrix.random([10000, 10000], dtype: :float64)
+  #   a = rand_mat.triu
+  #   b = NMatrix.random([10000, 10], dtype: :float64)
+  #   Benchmark.bm(10) do |bm|
+  #     bm.report('general') { a.solve(b) }
+  #     bm.report('upper_tri') { a.solve(b, form: :upper_tri) }
+  #   end
+  #   #                   user     system      total        real
+  #   #  general     73.170000   0.670000  73.840000 ( 73.810086)
+  #   #  upper_tri    0.180000   0.000000   0.180000 (  0.182491)
+  #
+  def solve(b, opts = {})
     raise(ShapeError, "Must be called on square matrix") unless self.dim == 2 && self.shape[0] == self.shape[1]
     raise(ShapeError, "number of rows of b must equal number of cols of self") if 
       self.shape[1] != b.shape[0]
-    raise ArgumentError, "only works with dense matrices" if self.stype != :dense
-    raise ArgumentError, "only works for non-integer, non-object dtypes" if 
+    raise(ArgumentError, "only works with dense matrices") if self.stype != :dense
+    raise(ArgumentError, "only works for non-integer, non-object dtypes") if 
       integer_dtype? or object_dtype? or b.integer_dtype? or b.object_dtype?
 
-    x     = b.clone
-    clone = self.clone
-    n = self.shape[0]
+    opts = { form: :general }.merge(opts)
+    x    = b.clone
+    n    = self.shape[0]
     nrhs = b.shape[1]
 
-    ipiv = NMatrix::LAPACK.clapack_getrf(:row, n, n, clone, n)
-    # When we call clapack_getrs with :row, actually only the first matrix
-    # (i.e. clone) is interpreted as row-major, while the other matrix (x)
-    # is interpreted as column-major. See here: http://math-atlas.sourceforge.net/faq.html#RowSolve
-    # So we must transpose x before and after
-    # calling it.
-    x = x.transpose
-    NMatrix::LAPACK.clapack_getrs(:row, :no_transpose, n, nrhs, clone, n, ipiv, x, n)
-    x.transpose
+    case opts[:form] 
+    when :general
+      clone = self.clone
+      ipiv = NMatrix::LAPACK.clapack_getrf(:row, n, n, clone, n)
+      # When we call clapack_getrs with :row, actually only the first matrix
+      # (i.e. clone) is interpreted as row-major, while the other matrix (x)
+      # is interpreted as column-major. See here: http://math-atlas.sourceforge.net/faq.html#RowSolve
+      # So we must transpose x before and after
+      # calling it.
+      x = x.transpose
+      NMatrix::LAPACK.clapack_getrs(:row, :no_transpose, n, nrhs, clone, n, ipiv, x, n)
+      x.transpose
+    when :upper_tri, :upper_triangular
+      raise(ArgumentError, "upper triangular solver does not work with complex dtypes") if
+        complex_dtype? or b.complex_dtype?
+      # this is the correct function call; see https://github.com/SciRuby/nmatrix/issues/374
+      NMatrix::BLAS::cblas_trsm(:row, :left, :upper, false, :nounit, n, nrhs, 1.0, self, n, x, nrhs)
+      x
+    when :lower_tri, :lower_triangular
+      raise(ArgumentError, "lower triangular solver does not work with complex dtypes") if
+        complex_dtype? or b.complex_dtype?
+      # this is a workaround; see https://github.com/SciRuby/nmatrix/issues/422
+      x = x.transpose
+      NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nounit, nrhs, n, 1.0, self, n, x, n)
+      x.transpose
+    when :pos_def, :positive_definite
+      u, l = self.factorize_cholesky
+      z = l.solve(b, form: :lower_tri)
+      u.solve(z, form: :upper_tri)
+    else
+      raise(ArgumentError, "#{opts[:form]} is not a valid form option")
+    end
   end
 
   #