nmatrix 0.0.9 → 0.1.0.rc1

data/ext/nmatrix/storage/yale/yale.h

@@ -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.
 //
@@ -89,7 +89,11 @@ extern "C" {
   void          nm_yale_storage_delete_ref(STORAGE* s);
   void					nm_yale_storage_init(YALE_STORAGE* s, void* default_val);
   void					nm_yale_storage_mark(STORAGE*);
-
+  void          nm_yale_storage_register(const STORAGE* s);
+  void          nm_yale_storage_unregister(const STORAGE* s);
+  void		nm_yale_storage_register_a(void* a, size_t size);
+  void		nm_yale_storage_unregister_a(void* a, size_t size); 
+    
   ///////////////
   // Accessors //
   ///////////////

data/ext/nmatrix/types.h

@@ -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.
 //

data/ext/nmatrix/util/io.cpp

@@ -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.
 //
@@ -75,7 +75,7 @@ template <typename DType, typename MDType>
 char* matlab_cstring_to_dtype_string(size_t& result_len, const char* str, size_t bytes) {
 
   result_len   = sizeof(DType) * bytes / sizeof(MDType);
-  char* result = ALLOC_N(char, result_len);
+  char* result = NM_ALLOC_N(char, result_len);
 
   if (bytes % sizeof(MDType) != 0) {
     rb_raise(rb_eArgError, "the given string does not divide evenly for the given MATLAB dtype");
@@ -223,7 +223,7 @@ static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from, VALUE
 
   // Encode as 8-bit ASCII with a length -- don't want to hiccup on \0
   VALUE result = rb_str_new(repacked_data, repacked_data_length);
-  xfree(repacked_data); // Don't forget to free what we allocated!
+  NM_FREE(repacked_data); // Don't forget to free what we allocated!
 
   return result;
 }
@@ -246,7 +246,7 @@ static VALUE nm_rbstring_merge(VALUE self, VALUE rb_real, VALUE rb_imaginary, VA
   char *real        = RSTRING_PTR(rb_real),
        *imag        = RSTRING_PTR(rb_imaginary);
 
-  char* merge       = ALLOCA_N(char, RSTRING_LEN(rb_real)*2);
+  char* merge       = NM_ALLOCA_N(char, RSTRING_LEN(rb_real)*2);
 
   size_t merge_pos  = 0;
 

data/ext/nmatrix/util/io.h

@@ -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.
 //

data/ext/nmatrix/util/sl_list.cpp

@@ -1,6 +1,16 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// 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.
 //
@@ -31,6 +41,8 @@
 
 #include "sl_list.h"
 
+#include "storage/list/list.h"
+
 namespace nm { namespace list {
 
 /*
@@ -58,7 +70,7 @@ namespace nm { namespace list {
  * Creates an empty linked list.
  */
 LIST* create(void) {
-  LIST* list = ALLOC( LIST );
+  LIST* list = NM_ALLOC( LIST );
   list->first = NULL;
   return list;
 }
@@ -77,18 +89,19 @@ void del(LIST* list, size_t recursions) {
 
     if (recursions == 0) {
       //fprintf(stderr, "    free_val: %p\n", curr->val);
-      xfree(curr->val);
+      nm_list_storage_completely_unregister_node(curr);
+      NM_FREE(curr->val);
       
     } else {
       //fprintf(stderr, "    free_list: %p\n", list);
       del((LIST*)curr->val, recursions - 1);
     }
 
-    xfree(curr);
+    NM_FREE(curr);
     curr = next;
   }
   //fprintf(stderr, "    free_list: %p\n", list);
-  xfree(list);
+  NM_FREE(list);
 }
 
 /*
@@ -122,10 +135,10 @@ void mark(LIST* list, size_t recursions) {
  * checks, just inserts.
  */
 NODE* insert_first_node(LIST* list, size_t key, void* val, size_t val_size) {
-  NODE* ins   = ALLOC(NODE);
+  NODE* ins   = NM_ALLOC(NODE);
   ins->next   = list->first;
 
-  void* val_copy = ALLOC_N(char, val_size);
+  void* val_copy = NM_ALLOC_N(char, val_size);
   memcpy(val_copy, val, val_size);
 
   ins->val    = reinterpret_cast<void*>(val_copy);
@@ -136,7 +149,7 @@ NODE* insert_first_node(LIST* list, size_t key, void* val, size_t val_size) {
 }
 
 NODE* insert_first_list(LIST* list, size_t key, LIST* l) {
-  NODE* ins   = ALLOC(NODE);
+  NODE* ins   = NM_ALLOC(NODE);
   ins->next   = list->first;
 
   ins->val    = reinterpret_cast<void*>(l);
@@ -160,7 +173,7 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
   	// List is empty
   	
     //if (!(ins = malloc(sizeof(NODE)))) return NULL;
-    ins = ALLOC(NODE);
+    ins = NM_ALLOC(NODE);
     ins->next             = NULL;
     ins->val              = val;
     ins->key              = key;
@@ -172,7 +185,7 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
   	// Goes at the beginning of the list
   	
     //if (!(ins = malloc(sizeof(NODE)))) return NULL;
-    ins = ALLOC(NODE);
+    ins = NM_ALLOC(NODE);
     ins->next             = list->first;
     ins->val              = val;
     ins->key              = key;
@@ -187,11 +200,11 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
   if (ins->key == key) {
     // key already exists
     if (replace) {
-      xfree(ins->val);
+      nm_list_storage_completely_unregister_node(ins);
+      NM_FREE(ins->val);
       ins->val = val;
-      
     } else {
-    	xfree(val);
+      NM_FREE(val);
     }
     
     return ins;
@@ -208,7 +221,7 @@ NODE* insert(LIST* list, bool replace, size_t key, void* val) {
  */
 NODE* insert_after(NODE* node, size_t key, void* val) {
   //if (!(ins = malloc(sizeof(NODE)))) return NULL;
-  NODE* ins = ALLOC(NODE);
+  NODE* ins = NM_ALLOC(NODE);
 
   // insert 'ins' between 'node' and 'node->next'
   ins->next  = node->next;
@@ -231,7 +244,7 @@ NODE* replace_insert_after(NODE* node, size_t key, void* val, bool copy, size_t
     // Should we copy into the current one or free and insert?
     if (copy) memcpy(node->next->val, val, copy_size);
     else {
-      xfree(node->next->val);
+      NM_FREE(node->next->val);
       node->next->val = val;
     }
 
@@ -240,7 +253,7 @@ NODE* replace_insert_after(NODE* node, size_t key, void* val, bool copy, size_t
   } else { // no next node, or if there is one, it's greater than the current key
 
     if (copy) {
-      void* val_copy = ALLOC_N(char, copy_size);
+      void* val_copy = NM_ALLOC_N(char, copy_size);
       memcpy(val_copy, val, copy_size);
       return insert_after(node, key, val_copy);
     } else {
@@ -256,7 +269,7 @@ NODE* replace_insert_after(NODE* node, size_t key, void* val, bool copy, size_t
  * Functions analogously to list::insert but this inserts a copy of the value instead of the original.
  */
 NODE* insert_copy(LIST *list, bool replace, size_t key, void *val, size_t size) {
-  void *copy_val = ALLOC_N(char, size);
+  void *copy_val = NM_ALLOC_N(char, size);
   memcpy(copy_val, val, size);
 
   return insert(list, replace, key, copy_val);
@@ -272,7 +285,7 @@ void* remove_by_node(LIST* list, NODE* prev, NODE* rm) {
   else        prev->next  = rm->next;
 
   void* val   = rm->val;
-  xfree(rm);
+  NM_FREE(rm);
 
   return val;
 }
@@ -296,7 +309,7 @@ void* remove_by_key(LIST* list, size_t key) {
     rm  = list->first;
     
     list->first = rm->next;
-    xfree(rm);
+    NM_FREE(rm);
     
     return val;
   }
@@ -313,7 +326,7 @@ void* remove_by_key(LIST* list, size_t key) {
 
     // get the value and free the memory for the node
     val = rm->val;
-    xfree(rm);
+    NM_FREE(rm);
 
     return val;
   }
@@ -348,7 +361,7 @@ bool remove_recursive(LIST* list, const size_t* coords, const size_t* offsets, c
 
       if (remove_parent) { // now empty -- so remove the sub-list
 //        std::cerr << r << ": removing parent list at " << n->key << std::endl;
-        xfree(remove_by_node(list, prev, n));
+        NM_FREE(remove_by_node(list, prev, n));
 
         if (prev) n  = prev->next && node_is_within_slice(prev->next, coords[r] + offsets[r], lengths[r]) ? prev->next : NULL;
         else      n  = node_is_within_slice(list->first, coords[r] + offsets[r], lengths[r]) ? list->first : NULL;
@@ -367,7 +380,7 @@ bool remove_recursive(LIST* list, const size_t* coords, const size_t* offsets, c
 
     while (n) {
 //      std::cerr << r << ": removing node at " << n->key << std::endl;
-      xfree(remove_by_node(list, prev, n));
+      NM_FREE(remove_by_node(list, prev, n));
 
       if (prev) n  = prev->next && node_is_within_slice(prev->next, coords[r] + offsets[r], lengths[r]) ? prev->next : NULL;
       else      n  = node_is_within_slice(list->first, coords[r] + offsets[r], lengths[r]) ? list->first : NULL;
@@ -505,7 +518,7 @@ void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions) {
   if (rhs->first) {
     // copy head node
     rcurr = rhs->first;
-    lcurr = lhs->first = ALLOC( NODE );
+    lcurr = lhs->first = NM_ALLOC( NODE );
 
     while (rcurr) {
       lcurr->key = rcurr->key;
@@ -513,14 +526,14 @@ void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions) {
       if (recursions == 0) {
       	// contents is some kind of value
 
-        lcurr->val = ALLOC( LDType );
+        lcurr->val = NM_ALLOC( LDType );
 
         *reinterpret_cast<LDType*>(lcurr->val) = *reinterpret_cast<RDType*>( rcurr->val );
 
       } else {
       	// contents is a list
 
-        lcurr->val = ALLOC( LIST );
+        lcurr->val = NM_ALLOC( LIST );
 
         cast_copy_contents<LDType, RDType>(
           reinterpret_cast<LIST*>(lcurr->val),
@@ -530,7 +543,7 @@ void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions) {
       }
 
       if (rcurr->next) {
-      	lcurr->next = ALLOC( NODE );
+      	lcurr->next = NM_ALLOC( NODE );
 
       } else {
       	lcurr->next = NULL;

data/ext/nmatrix/util/sl_list.h

@@ -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.
 //
@@ -90,7 +90,7 @@ 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 = ALLOC(Type);
+	Type* val_mem = NM_ALLOC(Type);
 	*val_mem = val;
 	
 	if (node == NULL) {

data/ext/nmatrix/util/util.h

@@ -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.
 //

data/lib/nmatrix.rb

@@ -8,8 +8,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.
 #

data/lib/nmatrix/blas.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.
 #

data/lib/nmatrix/enumerate.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.
 #
@@ -66,9 +66,12 @@ class 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?
-    cp = self.dup
+    cp = self.cast(dtype: :object)
     cp.map! &bl
     cp
   end
@@ -83,10 +86,18 @@ class NMatrix
   #
   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
-    self
+    #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
 
 
@@ -215,7 +226,7 @@ class NMatrix
     first_as_acc = false
 
     if initial then
-      acc = NMatrix.new(new_shape, initial, :dtype => dtype || self.dtype)
+      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
@@ -238,4 +249,4 @@ class NMatrix
   alias :reduce_along_dim :inject_rank
   alias :inject_along_dim :inject_rank
 
-end
+end

data/lib/nmatrix/io/market.rb

@@ -1,4 +1,3 @@
-#--
 # = NMatrix
 #
 # A linear algebra library for scientific computation in Ruby.
@@ -9,8 +8,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/io/mat5_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.
 #