nmatrix 0.1.0.rc3 → 0.1.0.rc4

data/ext/nmatrix/storage/list/list.cpp

@@ -183,7 +183,7 @@ static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, con
         nm_list_storage_register_list(val, rec-1);
 	temp_vals.push_front(val);
         nm::list::insert_helper(x, xcurr, curr->key - offset, val);
-      } 
+      }
       curr = curr->next;
       if (curr && curr->key - offset >= x_shape) curr = NULL;
     }
@@ -191,7 +191,10 @@ static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, con
   } else {
     std::list<VALUE*> temp_vals;
     while (curr) {
-      VALUE val, s_val = rubyobj_from_cval(curr->val, s.dtype()).rval;
+      VALUE val, s_val;
+      if (s.dtype() == nm::RUBYOBJ) s_val = (*reinterpret_cast<nm::RubyObject*>(curr->val)).rval;
+      else                          s_val = rubyobj_from_cval(curr->val, s.dtype()).rval;
+
       if (rev) val = rb_yield_values(2, t_init, s_val);
       else     val = rb_yield_values(2, s_val, t_init);
 
@@ -262,7 +265,7 @@ static void map_stored_r(RecurseData& result, RecurseData& left, LIST* x, const
       size_t key;
       VALUE  val;
 
-      val   = rb_yield_values(1, rubyobj_from_cval(lcurr->val, left.dtype()).rval);
+      val   = rb_yield_values(1, left.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(lcurr->val) : rubyobj_from_cval(lcurr->val, left.dtype()).rval);
       key   = lcurr->key - left.offset(rec);
       lcurr = lcurr->next;
 
@@ -535,7 +538,7 @@ void set(VALUE left, SLICE* slice, VALUE right) {
   NM_CONSERVATIVE(nm_register_value(left));
   NM_CONSERVATIVE(nm_register_value(right));
   LIST_STORAGE* s = NM_STORAGE_LIST(left);
-  
+
   std::pair<NMATRIX*,bool> nm_and_free =
     interpret_arg_as_dense_nmatrix(right, NM_DTYPE(left));
 
@@ -701,11 +704,11 @@ static void __nm_list_storage_unregister_temp_list_list(std::list<LIST*>& temp_v
 }
 
 void nm_list_storage_register_node(const NODE* curr) {
-  nm_register_value(*reinterpret_cast<VALUE*>(curr->val));      
+  nm_register_value(*reinterpret_cast<VALUE*>(curr->val));
 }
 
 void nm_list_storage_unregister_node(const NODE* curr) {
-  nm_unregister_value(*reinterpret_cast<VALUE*>(curr->val));      
+  nm_unregister_value(*reinterpret_cast<VALUE*>(curr->val));
 }
 
 /**
@@ -775,13 +778,13 @@ void nm_list_storage_unregister(const STORAGE* s) {
  * Documentation goes here.
  */
 static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice) {
-  size_t r;
-  LIST*  l = s->rows;
-  NODE*  n;
+  LIST* l = s->rows;
+  NODE* n;
 
-  for (r = 0; r < s->dim; r++) {
+  for (size_t r = 0; r < s->dim; r++) {
     n = nm::list::find(l, s->offset[r] + slice->coords[r]);
-    if (n)  l = reinterpret_cast<LIST*>(n->val);
+
+    if (n) l = reinterpret_cast<LIST*>(n->val);
     else return NULL;
   }
 
@@ -798,7 +801,7 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
   NM_CONSERVATIVE(nm_register_value(stack));
 
   if (rec) {
-    for (long index = 0; index < s.ref_shape(rec); ++index) {
+    for (unsigned long index = 0; index < s.ref_shape(rec); ++index) {
       // Don't do an unshift/shift here -- we'll let that be handled in the lowest-level iteration (recursions == 0)
       rb_ary_push(stack, LONG2NUM(index));
       each_empty_with_indices_r(s, rec-1, stack);
@@ -806,7 +809,7 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
     }
   } else {
     rb_ary_unshift(stack, empty);
-    for (long index = 0; index < s.ref_shape(rec); ++index) {
+    for (unsigned long index = 0; index < s.ref_shape(rec); ++index) {
       rb_ary_push(stack, LONG2NUM(index));
       rb_yield_splat(stack);
       rb_ary_pop(stack);
@@ -833,7 +836,7 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
 
 
   if (rec) {
-    for (long index = 0; index < shape; ++index) { // index in reference
+    for (unsigned long index = 0; index < shape; ++index) { // index in reference
       rb_ary_push(stack, LONG2NUM(index));
       if (!curr || index < curr->key - offset) {
         each_empty_with_indices_r(s, rec-1, stack);
@@ -844,7 +847,7 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
       rb_ary_pop(stack);
     }
   } else {
-    for (long index = 0; index < shape; ++index) {
+    for (unsigned long index = 0; index < shape; ++index) {
 
       rb_ary_push(stack, LONG2NUM(index));
 
@@ -875,7 +878,7 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
   if (s.dtype() == nm::RUBYOBJ)
     nm_list_storage_register_list(l, rec);
   NM_CONSERVATIVE(nm_register_value(stack));
-  
+
   NODE* curr = l->first;
 
   size_t offset = s.offset(rec);
@@ -919,7 +922,6 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
 }
 
 
-
 /*
  * Each/each-stored iterator, brings along the indices.
  */
@@ -945,21 +947,19 @@ VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
 
 
 /*
- * map merged stored iterator. Always returns a matrix containing RubyObjects which probably needs to be casted.
+ * map merged stored iterator. Always returns a matrix containing RubyObjects
+ * which probably needs to be casted.
  */
 VALUE nm_list_map_stored(VALUE left, VALUE init) {
   NM_CONSERVATIVE(nm_register_value(left));
   NM_CONSERVATIVE(nm_register_value(init));
 
-  bool scalar = false;
-
-  LIST_STORAGE *s   = NM_STORAGE_LIST(left);
+  LIST_STORAGE *s = NM_STORAGE_LIST(left);
 
-  // For each matrix, if it's a reference, we want to deal directly with the original (with appropriate offsetting)
+  // For each matrix, if it's a reference, we want to deal directly with the
+  // original (with appropriate offsetting)
   nm::list_storage::RecurseData sdata(s);
 
-  void* scalar_init = NULL;
-
   //if (!rb_block_given_p()) {
   //  rb_raise(rb_eNotImpError, "RETURN_SIZED_ENUMERATOR probably won't work for a map_merged since no merged object is created");
   //}
@@ -1077,14 +1077,14 @@ static LIST* slice_copy(const LIST_STORAGE* src, LIST* src_rows, size_t* coords,
   nm_list_storage_register(src);
   void *val = NULL;
   int key;
-  
+
   LIST* dst_rows = nm::list::create();
   NODE* src_node = src_rows->first;
   std::list<VALUE*> temp_vals;
   std::list<LIST*> temp_lists;
   while (src_node) {
     key = src_node->key - (src->offset[n] + coords[n]);
-    
+
     if (key >= 0 && (size_t)key < lengths[n]) {
       if (src->dim - n > 1) {
         val = slice_copy( src,
@@ -1130,7 +1130,6 @@ void* nm_list_storage_get(const STORAGE* storage, SLICE* slice) {
     NODE* n = list_storage_get_single_node(s, slice);
     nm_list_storage_unregister(s);
     return (n ? n->val : s->default_val);
-
   } else {
     void *init_val = NM_ALLOC_N(char, DTYPE_SIZES[s->dtype]);
     memcpy(init_val, s->default_val, DTYPE_SIZES[s->dtype]);
@@ -1141,11 +1140,13 @@ void* nm_list_storage_get(const STORAGE* storage, SLICE* slice) {
     memcpy(shape, slice->lengths, sizeof(size_t) * s->dim);
 
     ns = nm_list_storage_create(s->dtype, shape, s->dim, init_val);
-  
+
     ns->rows = slice_copy(s, s->rows, slice->coords, slice->lengths, 0);
 
-    if (s->dtype == nm::RUBYOBJ)
+    if (s->dtype == nm::RUBYOBJ) {
       nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
+    }
+
     nm_list_storage_unregister(s);
 
     return ns;
@@ -1166,14 +1167,13 @@ void* nm_list_storage_ref(const STORAGE* storage, SLICE* slice) {
     NODE* n = list_storage_get_single_node(s, slice);
     nm_list_storage_unregister(s);
     return (n ? n->val : s->default_val);
-  } 
-  else {
-    ns              = NM_ALLOC( LIST_STORAGE );
-    
-    ns->dim         = s->dim;
-    ns->dtype       = s->dtype;
-    ns->offset      = NM_ALLOC_N(size_t, ns->dim);
-    ns->shape       = NM_ALLOC_N(size_t, ns->dim);
+  } else {
+    ns = NM_ALLOC( LIST_STORAGE );
+
+    ns->dim = s->dim;
+    ns->dtype = s->dtype;
+    ns->offset = NM_ALLOC_N(size_t, ns->dim);
+    ns->shape = NM_ALLOC_N(size_t, ns->dim);
 
     for (size_t i = 0; i < ns->dim; ++i) {
       ns->offset[i] = slice->coords[i] + s->offset[i];
@@ -1182,7 +1182,7 @@ void* nm_list_storage_ref(const STORAGE* storage, SLICE* slice) {
 
     ns->rows        = s->rows;
     ns->default_val = s->default_val;
-    
+
     s->src->count++;
     ns->src         = s->src;
     nm_list_storage_unregister(s);
@@ -1204,13 +1204,14 @@ static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coo
   // drill down into the structure
   NODE* node = NULL;
   if (dest->dim - n > 1) {
-    std::list<LIST*> temp_nodes; 
+    std::list<LIST*> temp_nodes;
     for (size_t i = 0; i < lengths[n]; ++i) {
 
       size_t key = i + dest->offset[n] + coords[n];
 
       if (!node) {
-        node = nm::list::insert(l, false, key, nm::list::create()); // try to insert list
+        // try to insert list
+        node = nm::list::insert(l, false, key, nm::list::create());
       } else if (!node->next || (node->next && node->next->key > key)) {
         node = nm::list::insert_after(node, key, nm::list::create());
       } else {
@@ -1364,20 +1365,20 @@ VALUE nm_list_storage_to_hash(const LIST_STORAGE* s, const nm::dtype_t dtype) {
 size_t nm_list_storage_count_elements_r(const LIST* l, size_t recursions) {
   size_t count = 0;
   NODE* curr = l->first;
-  
+
   if (recursions) {
     while (curr) {
       count += nm_list_storage_count_elements_r(reinterpret_cast<const LIST*>(curr->val), recursions - 1);
       curr   = curr->next;
     }
-    
+
   } else {
     while (curr) {
       ++count;
       curr = curr->next;
     }
   }
-  
+
   return count;
 }
 
@@ -1387,7 +1388,7 @@ size_t nm_list_storage_count_elements_r(const LIST* l, size_t recursions) {
 size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s) {
   NODE *i_curr, *j_curr;
   size_t count = 0;
-  
+
   if (s->dim != 2) {
   	rb_raise(rb_eNotImpError, "non-diagonal element counting only defined for dim = 2");
   }
@@ -1403,7 +1404,7 @@ size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s) {
       if (i != j)  	++count;
     }
   }
-  
+
   return count;
 }
 
@@ -1419,7 +1420,7 @@ LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs) {
   nm_list_storage_register(rhs);
   size_t *shape = NM_ALLOC_N(size_t, rhs->dim);
   memcpy(shape, rhs->shape, sizeof(size_t) * rhs->dim);
-  
+
   void *init_val = NM_ALLOC_N(char, DTYPE_SIZES[rhs->dtype]);
   memcpy(init_val, rhs->default_val, DTYPE_SIZES[rhs->dtype]);
 
@@ -1483,7 +1484,7 @@ static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_dtype) {
 
   nm_list_storage_register(lhs);
   // TODO: Needs optimization. When matrix is reference it is copped twice.
-  if (rhs->src == rhs) 
+  if (rhs->src == rhs)
     nm::list::cast_copy_contents<LDType, RDType>(lhs->rows, rhs->rows, rhs->dim - 1);
   else {
     LIST_STORAGE *tmp = nm_list_storage_copy(rhs);

data/ext/nmatrix/util/io.cpp

@@ -251,7 +251,7 @@ static VALUE nm_rbstring_merge(VALUE self, VALUE rb_real, VALUE rb_imaginary, VA
   size_t merge_pos  = 0;
 
   // Merge the two sequences
-  for (size_t i = 0; i < RSTRING_LEN(rb_real); i += len) {
+  for (size_t i = 0; i < (size_t)RSTRING_LEN(rb_real); i += len) {
 
     // Copy real number
     memcpy(merge + merge_pos, real + i, len);
@@ -276,4 +276,4 @@ void nm_init_io() {
 
 
 
-}
+}

data/lib/nmatrix.rb

@@ -36,7 +36,6 @@ end
 
 require 'nmatrix/nmatrix.rb'
 require 'nmatrix/version.rb'
-#require 'nmatrix/nvector.rb'
 require 'nmatrix/blas.rb'
 require 'nmatrix/monkeys'
 require "nmatrix/shortcuts.rb"

data/lib/nmatrix/enumerate.rb

@@ -72,7 +72,7 @@ class NMatrix
   def map(&bl)
     return enum_for(:map) unless block_given?
     cp = self.cast(dtype: :object)
-    cp.map! &bl
+    cp.map!(&bl)
     cp
   end
 

data/lib/nmatrix/io/market.rb

@@ -210,7 +210,7 @@ module NMatrix::IO::Market
         line.lstrip!
         line, comment = line.split('%', 2) # ignore comments
         if line.size > 4
-          shape0, shape1, nz = line.split
+          shape0, shape1 = line.split
           mat = NMatrix.new(:list, [shape0.to_i, shape1.to_i], 0, dtype)
           break
         end

data/lib/nmatrix/io/mat_reader.rb

@@ -38,62 +38,62 @@ module NMatrix::IO::Matlab
   #
   class MatReader
     MDTYPE_UNPACK_ARGS = {
-      :miINT8		=> [Integer, {:signed			=> true,		:bytes => 1}],
-      :miUINT8	=> [Integer, {:signed			=> false,		:bytes => 1}],
-      :miINT16	=> [Integer, {:signed			=> true,		:bytes => 2}],
-      :miUINT16	=> [Integer, {:signed			=> false,		:bytes => 2}],
-      :miINT32	=> [Integer, {:signed			=> true,		:bytes => 4}],
-      :miUINT32	=> [Integer, {:signed			=> false,		:bytes => 4}],
-      :miSINGLE	=> [Float,   {:precision	=> :single,	:bytes => 4, :endian => :native}],
-      :miDOUBLE	=> [Float,   {:precision  => :double, :bytes => 4, :endian => :native}],
-      :miINT64	=> [Integer, {:signed			=> true,		:bytes => 8}],
-      :miUINT64	=> [Integer, {:signed			=> false,		:bytes => 8}]
+      :miINT8   => [Integer, {:signed    => true,    :bytes => 1}],
+      :miUINT8  => [Integer, {:signed    => false,   :bytes => 1}],
+      :miINT16  => [Integer, {:signed    => true,    :bytes => 2}],
+      :miUINT16 => [Integer, {:signed    => false,   :bytes => 2}],
+      :miINT32  => [Integer, {:signed    => true,    :bytes => 4}],
+      :miUINT32 => [Integer, {:signed    => false,   :bytes => 4}],
+      :miSINGLE => [Float,   {:precision => :single, :bytes => 4, :endian => :native}],
+      :miDOUBLE => [Float,   {:precision => :double, :bytes => 4, :endian => :native}],
+      :miINT64  => [Integer, {:signed    => true,    :bytes => 8}],
+      :miUINT64 => [Integer, {:signed    => false,   :bytes => 8}]
     }
 
     DTYPE_PACK_ARGS = {
-      :byte				=> [Integer,	{:signed		=> false,		:bytes => 1}],
-      :int8				=> [Integer,	{:signed		=> true,		:bytes => 1}],
-      :int16			=> [Integer,	{:signed		=> true,		:bytes => 2}],
-      :int32			=> [Integer,	{:signed		=> true,		:bytes => 4}],
-      :int64			=> [Integer,	{:signed		=> true,		:bytes => 8}],
-      :float32		=> [Float,		{:precision	=> :single,	:bytes => 4, :endian => :native}],
-      :float64		=> [Float,		{:precision	=> :double,	:bytes => 8, :endian => :native}],
-      :complex64	=> [Float,		{:precision	=> :single,	:bytes => 4, :endian => :native}], #2x
-      :complex128	=> [Float,		{:precision	=> :double,	:bytes => 8, :endian => :native}]
+      :byte       => [Integer, {:signed => false,      :bytes => 1}],
+      :int8       => [Integer, {:signed => true,       :bytes => 1}],
+      :int16      => [Integer, {:signed => true,       :bytes => 2}],
+      :int32      => [Integer, {:signed => true,       :bytes => 4}],
+      :int64      => [Integer, {:signed => true,       :bytes => 8}],
+      :float32    => [Float,   {:precision => :single, :bytes => 4, :endian => :native}],
+      :float64    => [Float,   {:precision => :double, :bytes => 8, :endian => :native}],
+      :complex64  => [Float,   {:precision => :single, :bytes => 4, :endian => :native}], #2x
+      :complex128 => [Float,   {:precision => :double, :bytes => 8, :endian => :native}]
     }
 
     ITYPE_PACK_ARGS = {
-      :uint8			=> [Integer,	{:signed		=> false,		:bytes => 1}],
-      :uint16			=> [Integer,	{:signed		=> false,		:bytes => 2}],
-      :uint32			=> [Integer,	{:signed		=> false,		:bytes => 4}],
-      :uint64			=> [Integer,	{:signed		=> false,		:bytes => 8}],
+      :uint8  => [Integer, {:signed => false, :bytes => 1}],
+      :uint16 => [Integer, {:signed => false, :bytes => 2}],
+      :uint32 => [Integer, {:signed => false, :bytes => 4}],
+      :uint64 => [Integer, {:signed => false, :bytes => 8}],
     }
 
     NO_REPACK = [:miINT8, :miUINT8, :miINT16, :miINT32, :miSINGLE, :miDOUBLE, :miINT64]
 
     # Convert from MATLAB dtype to NMatrix dtype.
     MDTYPE_TO_DTYPE = {
-      :miUINT8	=> :byte,
-      :miINT8		=> :int8,
-      :miINT16	=> :int16,
-      :miUINT16	=> :int16,
-      :miINT32	=> :int32,
-      :miUINT32	=> :int32,
-      :miINT64	=> :int64,
-      :miUINT64	=> :int64,
-      :miSINGLE	=> :float32,
-      :miDOUBLE	=> :float64
+      :miUINT8  => :byte,
+      :miINT8   => :int8,
+      :miINT16  => :int16,
+      :miUINT16 => :int16,
+      :miINT32  => :int32,
+      :miUINT32 => :int32,
+      :miINT64  => :int64,
+      :miUINT64 => :int64,
+      :miSINGLE => :float32,
+      :miDOUBLE => :float64
     }
 
     MDTYPE_TO_ITYPE = {
-      :miUINT8 => :uint8,
-      :miINT8 => :uint8,
-      :miINT16	=> :uint16,
-      :miUINT16	=> :uint16,
-      :miINT32	=> :uint32,
-      :miUINT32	=> :uint32,
-      :miINT64	=> :uint64,
-      :miUINT64	=> :uint64
+      :miUINT8  => :uint8,
+      :miINT8   => :uint8,
+      :miINT16  => :uint16,
+      :miUINT16 => :uint16,
+      :miINT32  => :uint32,
+      :miUINT32 => :uint32,
+      :miINT64  => :uint64,
+      :miUINT64 => :uint64
     }
 
     # Before release v7.1 (release 14) matlab (TM) used the system

data/lib/nmatrix/lapack.rb

@@ -193,7 +193,6 @@ class NMatrix
       # Perform eigenvalue decomposition on a matrix using LAPACK's xGEEV function.
       #
       def geev(matrix, which=:both)
-        result = alloc_evd_result(matrix)
         jobvl = (which == :both || which == :left) ? :left : false
         jobvr = (which == :both || which == :right) ? :right : false
 

data/lib/nmatrix/math.rb

@@ -607,6 +607,49 @@ protected
     self.__dense_map__ { |l| -l }.cast(stype, dtype)
   end
 
+  # These are for calculating the floor or ceil of matrix
+  def dtype_for_floor_or_ceil
+    if self.integer_dtype? or [:complex64, :complex128, :object].include?(self.dtype)
+      return_dtype = dtype
+    elsif [:float32, :float64, :rational32,:rational64, :rational128].include?(self.dtype)
+      return_dtype = :int64
+    end
+
+    return_dtype
+  end
+
+  [:floor, :ceil].each do |meth|  
+    define_method("__list_unary_#{meth}__") do
+      return_dtype = dtype_for_floor_or_ceil
+
+      if [:complex64, :complex128].include?(self.dtype)
+        self.__list_map_stored__(nil) { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype) 
+      else
+        self.__list_map_stored__(nil) { |l| l.send(meth) }.cast(stype, return_dtype)   
+      end
+    end
+    
+    define_method("__yale_unary_#{meth}__") do 
+      return_dtype = dtype_for_floor_or_ceil
+
+      if [:complex64, :complex128].include?(self.dtype)
+        self.__yale_map_stored__ { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype) 
+      else
+        self.__yale_map_stored__ { |l| l.send(meth) }.cast(stype, return_dtype)   
+      end
+    end
+    
+    define_method("__dense_unary_#{meth}__") do
+      return_dtype = dtype_for_floor_or_ceil
+       
+      if [:complex64, :complex128].include?(self.dtype)
+        self.__dense_map__ { |l| Complex(l.real.send(meth), l.imag.send(meth)) }.cast(stype, return_dtype) 
+      else
+        self.__dense_map__ { |l| l.send(meth) }.cast(stype, return_dtype)   
+      end
+    end     
+  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