nmatrix 0.0.5 → 0.0.6

data/ext/nmatrix/storage/yale.h

@@ -90,13 +90,14 @@ 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_init(YALE_STORAGE* s);
+  void					nm_yale_storage_init(YALE_STORAGE* s, void* default_val);
   void					nm_yale_storage_mark(void*);
 
   ///////////////
   // Accessors //
   ///////////////
 
+  VALUE nm_yale_each_with_indices(VALUE nmatrix);
   VALUE nm_yale_each_stored_with_indices(VALUE nmatrix);
   void* nm_yale_storage_get(STORAGE* s, SLICE* slice);
   void*	nm_yale_storage_ref(STORAGE* s, SLICE* slice);
@@ -106,6 +107,9 @@ extern "C" {
   //void  nm_yale_storage_increment_ia_after(YALE_STORAGE* s, size_t ija_size, size_t i, size_t n);
 
   size_t  nm_yale_storage_get_size(const YALE_STORAGE* storage);
+  VALUE   nm_yale_default_value(VALUE self);
+  VALUE   nm_yale_map_stored(VALUE self);
+  VALUE   nm_yale_map_merged_stored(VALUE left, VALUE right, VALUE init);
 
   ///////////
   // Tests //
@@ -116,8 +120,7 @@ extern "C" {
   //////////
   // Math //
   //////////
-	
-	STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar);
+
   STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
 
   /////////////
@@ -163,13 +166,15 @@ extern "C" {
   // Copying and Casting //
   /////////////////////////
 
-  STORAGE*      nm_yale_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype);
+  STORAGE*      nm_yale_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype, void*);
   STORAGE*      nm_yale_storage_copy_transposed(const STORAGE* rhs_base);
 
 
 
   void nm_init_yale_functions(void);
 
+  VALUE nm_vector_set(int argc, VALUE* argv, VALUE self);
+
 
 } // end of extern "C" block
 
@@ -193,19 +198,26 @@ namespace nm { namespace yale_storage {
    * the zero value).
    *
    * Note: This sets a literal 0 value. If your dtype is RUBYOBJ (a Ruby object),
-   * it'll actually be INT2FIX(0) instead of a string of NULLs.
+   * it'll actually be INT2FIX(0) instead of a string of NULLs. You can actually
+   * set a default for Ruby objects other than zero -- you generally want it to
+   * be Qfalse, Qnil, or INT2FIX(0). The last is the default.
    */
   template <typename DType>
-  inline void clear_diagonal_and_zero(YALE_STORAGE* s) {
+  inline void clear_diagonal_and_zero(YALE_STORAGE* s, void* init_val) {
     DType* a = reinterpret_cast<DType*>(s->a);
 
     // Clear out the diagonal + one extra entry
-    for (size_t i = 0; i < s->shape[0]+1; ++i) // insert Ruby zeros
-      a[i] = 0;
+    if (init_val) {
+      for (size_t i = 0; i <= s->shape[0]; ++i) // insert Ruby zeros, falses, or whatever else.
+        a[i] = *reinterpret_cast<DType*>(init_val);
+    } else {
+      for (size_t i = 0; i <= s->shape[0]; ++i) // insert zeros.
+        a[i] = 0;
+    }
   }
 
   template <typename DType, typename IType>
-  void init(YALE_STORAGE* s);
+  void init(YALE_STORAGE* s, void* init_val);
 
   template <typename IType>
   size_t  get_size(const YALE_STORAGE* storage);

data/ext/nmatrix/ttable_helper.rb

@@ -2,9 +2,6 @@
 
 # A helper file for generating and maintaining template tables.
 
-def nullify(disabled) #:nodoc:
-  DTYPES.map { |t| if disabled.include?(t) then :NULL else t end }
-end
 
 DTYPES = [
           :uint8_t,
@@ -22,6 +19,10 @@ DTYPES = [
           :'nm::RubyObject'
          ]
 
+def nullify(disabled = []) #:nodoc:
+  DTYPES.map { |t| if disabled.include?(t) then :NULL else t end }
+end
+
 ITYPES = [
           :uint8_t,
           :uint16_t,
@@ -34,6 +35,7 @@ EWOPS = [
          :'nm::EW_SUB',
          :'nm::EW_MUL',
          :'nm::EW_DIV',
+         :'nm::EW_POW',
          :'nm::EW_MOD',
          :'nm::EW_EQEQ',
          :'nm::EW_NEQ',
@@ -44,19 +46,19 @@ EWOPS = [
         ]
 
 LR_ALLOWED = {
-  :uint8_t	 		=> nullify([:RubyObject]),
-  :int8_t				=> nullify([:RubyObject]),
-  :int16_t			=> nullify([:RubyObject]),
-  :int32_t			=> nullify([:RubyObject]),
-  :int64_t			=> nullify([:RubyObject]),
-  :float32_t		=> nullify([:RubyObject]),
-  :float64_t		=> nullify([:RubyObject]),
-  :Complex64		=> nullify([:RubyObject]),
-  :Complex128		=> nullify([:RubyObject]),
-  :Rational32		=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128', :'nm::RubyObject']),
-  :Rational64		=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128', :'nm::RubyObject']),
-  :Rational128	=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128', :'nm::RubyObject']),
-  :RubyObject		=> nullify(DTYPES - [:RubyObject])
+  :uint8_t	 		=> DTYPES,
+  :int8_t				=> DTYPES,
+  :int16_t			=> DTYPES,
+  :int32_t			=> DTYPES,
+  :int64_t			=> DTYPES,
+  :float32_t		=> DTYPES,
+  :float64_t		=> DTYPES,
+  :'nm::Complex64'		=> DTYPES,
+  :'nm::Complex128'		=> DTYPES,
+  :'nm::Rational32'		=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128']),
+  :'nm::Rational64'		=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128']),
+  :'nm::Rational128'	=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128']),
+  :'nm::RubyObject'		=> DTYPES
 }
 
 lines =
@@ -106,21 +108,15 @@ lines =
       '}'
 
   when 'LR'
-    '{' +
-      DTYPES.map do |l_dtype|
-
-    '{' +
-      LR_ALLOWED[l_dtype].map do |r_dtype|
-      if r_dtype == :NULL
-        'NULL'
-      else
-        "fun<#{l_dtype}, #{r_dtype}>"
-      end
-    end.join(', ') +
-      '}'
-
-  end.join(",\n") +
-      '}'
+    '{' + DTYPES.map do |l_dtype|
+      '{' + LR_ALLOWED[l_dtype].map do |r_dtype|
+        if r_dtype == :NULL
+          'NULL'
+        else
+          "fun<#{l_dtype}, #{r_dtype}>"
+        end
+      end.join(', ') + '}'
+    end.join(",\n") + '}'
   end
 
 puts lines

data/ext/nmatrix/types.h

@@ -32,7 +32,7 @@
  * Standard Includes
  */
 
-#include <stdint.h>
+#include <cstdint>
 
 /*
  * Macros

data/ext/nmatrix/util/math.cpp

@@ -416,16 +416,14 @@ static VALUE nm_cblas_rotg(VALUE self, VALUE ab) {
       nm::math::cblas_rotg<double>,
       nm::math::cblas_rotg<nm::Complex64>,
       nm::math::cblas_rotg<nm::Complex128>,
-      nm::math::cblas_rotg<nm::Rational32>,
-      nm::math::cblas_rotg<nm::Rational64>,
-      nm::math::cblas_rotg<nm::Rational128>,
+      NULL, NULL, NULL, // no rationals
       nm::math::cblas_rotg<nm::RubyObject>
   };
 
   nm::dtype_t dtype = NM_DTYPE(ab);
 
   if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
+    rb_raise(nm_eDataTypeError, "this operation undefined for integer and rational vectors");
     return Qnil;
 
   } else {
@@ -488,7 +486,7 @@ static VALUE nm_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx, VALUE y, VAL
 
 
   if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
+    rb_raise(nm_eDataTypeError, "this operation undefined for integer vectors");
     return Qfalse;
   } else {
     void *pC, *pS;
@@ -547,16 +545,17 @@ static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
       nm::math::cblas_nrm2<float64_t,float64_t>,
       nm::math::cblas_nrm2<float32_t,nm::Complex64>,
       nm::math::cblas_nrm2<float64_t,nm::Complex128>,
-      nm::math::cblas_nrm2<nm::Rational32,nm::Rational32>,
-      nm::math::cblas_nrm2<nm::Rational64,nm::Rational64>,
-      nm::math::cblas_nrm2<nm::Rational128,nm::Rational128>,
+      //nm::math::cblas_nrm2<nm::Rational32,nm::Rational32>,
+      //nm::math::cblas_nrm2<nm::Rational64,nm::Rational64>,
+      //nm::math::cblas_nrm2<nm::Rational128,nm::Rational128>,
+      NULL, NULL, NULL,
       nm::math::cblas_nrm2<nm::RubyObject,nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
 
   if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this vector operation undefined for integer vectors");
+    rb_raise(nm_eDataTypeError, "this operation undefined for integer and rational vectors");
     return Qnil;
 
   } else {
@@ -1154,7 +1153,7 @@ static VALUE nm_clapack_getri(VALUE self, VALUE order, VALUE n, VALUE a, VALUE l
 
   if (!ttable[NM_DTYPE(a)]) {
     rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    // FIXME: Once BLAS dtypes are implemented, replace error above with the error below.
+    // FIXME: Once non-BLAS dtypes are implemented, replace error above with the error below.
     //rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
   } else {
     // Call either our version of getri or the LAPACK version.

data/ext/nmatrix/util/sl_list.cpp

@@ -58,13 +58,7 @@ namespace nm { namespace list {
  * Creates an empty linked list.
  */
 LIST* create(void) {
-  LIST* list;
-  
-  //if (!(list = malloc(sizeof(LIST)))) return NULL;
-  list = ALLOC( LIST );
-
-  //fprintf(stderr, "    create_list LIST: %p\n", list);
-
+  LIST* list = ALLOC( LIST );
   list->first = NULL;
   return list;
 }

data/ext/nmatrix/util/sl_list.h

@@ -110,124 +110,6 @@ inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type* ptr) {
 // Tests //
 ///////////
 
-/*
- * Do all values in a list == some value?
- *
- * Note that the template parameters should line up with the first two function parameters. This differs from most
- * other eqeq functions, which use left and right dtypes.
- */
-template <typename ListDType, typename ValueDType>
-bool eqeq_value(const LIST* l, const ValueDType* v, size_t recursions, size_t& checked) {
-  NODE *next, *curr = l->first;
-
-  while (curr) {
-    next = curr->next;
-
-    if (recursions == 0) {
-      ++checked;
-
-      if (*reinterpret_cast<ListDType*>(curr->val) != *v) return false;
-
-    } else if (!eqeq_value<ListDType,ValueDType>((LIST*)curr->val, v, recursions - 1, checked)) {
-      return false;
-    }
-
-    curr = next;
-  }
-
-  return true;
-}
-
-
-/*
- * Are all values in the two lists equal? If one is missing a value, but the
- * other isn't, does the value in the list match the default value?
- */
-template <typename LDType, typename RDType>
-bool eqeq(const LIST* left, const LIST* right, const LDType* left_val, const RDType* right_val, size_t recursions, size_t& checked) {
-  NODE *lnext = NULL, *lcurr = left->first, *rnext = NULL, *rcurr = right->first;
-
-  if (lcurr) lnext = lcurr->next;
-  if (rcurr) rnext = rcurr->next;
-
-  while (lcurr && rcurr) {
-
-    if (lcurr->key == rcurr->key) {
-    	// MATCHING KEYS
-
-      if (recursions == 0) {
-        ++checked;
-
-        if (*reinterpret_cast<LDType*>(lcurr->val) != *reinterpret_cast<RDType*>(rcurr->val)) return false;
-
-      } else if (!eqeq<LDType,RDType>(reinterpret_cast<LIST*>(lcurr->val), (LIST*)rcurr->val, left_val, right_val, recursions - 1, checked)) {
-        return false;
-      }
-
-      // increment both iterators
-      rcurr = rnext;
-      if (rcurr) rnext = rcurr->next;
-      lcurr = lnext;
-      if (lcurr) lnext = lcurr->next;
-
-    } else if (lcurr->key < rcurr->key) {
-    	// NON-MATCHING KEYS
-
-      if (recursions == 0) {
-        // compare left entry to right default value
-        ++checked;
-
-        if (*reinterpret_cast<LDType*>(lcurr->val) != *right_val) return false;
-
-      } else if (!eqeq_value<LDType,RDType>(reinterpret_cast<LIST*>(lcurr->val), right_val, recursions - 1, checked)) {
-        return false;
-      }
-
-      // increment left iterator
-      lcurr = lnext;
-      if (lcurr) lnext = lcurr->next;
-
-    } else {
-			// if (rcurr->key < lcurr->key)
-
-      if (recursions == 0) {
-        // compare right entry to left default value
-        ++checked;
-
-        if (*reinterpret_cast<RDType*>(rcurr->val) != *left_val) return false;
-
-      } else if (!eqeq_value<RDType,LDType>(reinterpret_cast<LIST*>(rcurr->val), left_val, recursions - 1, checked)) {
-        return false;
-      }
-
-      // increment right iterator
-      rcurr = rnext;
-      if (rcurr) rnext = rcurr->next;
-    }
-
-  }
-
-  /*
-   * One final check, in case we get to the end of one list but not the other
-   * one.
-   */
-  if (lcurr) {
-  	// nothing left in right-hand list
-  	if (*reinterpret_cast<LDType*>(lcurr->val) != *right_val) return false;
-
-  } else if (rcurr) {
-  	// nothing left in left-hand list
-  	if (*reinterpret_cast<RDType*>(rcurr->val) != *left_val) return false;
-
-  }
-
-  /*
-   * Nothing different between the two lists -- but make sure after this return
-   * that you compare the default values themselves, if we haven't visited
-   * every value in the two matrices.
-   */
-  return true;
-}
 
 /////////////
 // Utility //

data/lib/nmatrix/blas.rb

@@ -159,43 +159,84 @@ module NMatrix::BLAS
 
     #
     # call-seq:
-    #     rot(x, y, c, s)
+    #     rot(x, y, c, s) -> [NVector, NVector]
     #
     # Apply plane rotation.
     #
     # * *Arguments* :
-    #   - +x+ ->
-    #   - +y+ ->
-    #   - +s+ ->
-    #   - +c+ ->
-    #   - +incx+ ->
-    #   - +incy+ ->
-    #   - +n+ ->
+    #   - +x+ -> NVector
+    #   - +y+ -> NVector
+    #   - +c+ -> cosine of the angle of rotation
+    #   - +s+ -> sine of the angle of rotation
+    #   - +incx+ -> stride of NVector +x+
+    #   - +incy+ -> stride of NVector +y+
+    #   - +n+ -> number of elements to consider in x and y
+    #   - +in_place+ -> true if it's okay to modify the supplied +x+ and +y+ parameters directly; false if not. Default is false.
     # * *Returns* :
     #   - Array with the results, in the format [xx, yy]
     # * *Raises* :
-    #   - +ArgumentError+ -> Expected dense NMatrices as first two arguments.
-    #   - +ArgumentError+ -> Nmatrix dtype mismatch.
+    #   - +ArgumentError+ -> Expected dense NVectors as first two arguments.
+    #   - +ArgumentError+ -> NMatrix dtype mismatch.
     #   - +ArgumentError+ -> Need to supply n for non-standard incx, incy values.
     #
-    def rot(x, y, c, s, incx = 1, incy = 1, n = nil)
-      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
+    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, '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 > y.size ? y.size : x.size
+      n ||= [x.size/incx.abs, y.size/incy.abs].min
+
+      if in_place
+        ::NMatrix::BLAS.cblas_rot(n, x, incx, y, incy, c, s)
+        return [x,y]
+      else
+        xx = x.clone
+        yy = y.clone
+
+        ::NMatrix::BLAS.cblas_rot(n, xx, incx, yy, incy, c, s)
+
+        return [xx,yy]
+      end
+    end
+
+
+    #
+    # call-seq:
+    #     rot!(x, y, c, s) -> [NVector, NVector]
+    #
+    # Apply plane rotation directly to +x+ and +y+.
+    #
+    # See rot for arguments.
+    def rot!(x, y, c, s, incx = 1, incy = 1, n = nil)
+      rot(x,y,c,s,incx,incy,n,true)
+    end
 
-      xx = x.clone
-      yy = y.clone
 
-      ::NMatrix::BLAS.cblas_rot(n, xx, incx, yy, incy, c, s)
+    #
+    # call-seq:
+    #     rotg(ab) -> [Numeric, Numeric]
+    #
+    # Apply givens plane rotation to the coordinates (a,b), returning the cosine and sine of the angle theta.
+    #
+    # Since the givens rotation includes a square root, integers and rationals are disallowed.
+    #
+    # * *Arguments* :
+    #   - +ab+ -> NVector with two elements
+    # * *Returns* :
+    #   - Array with the results, in the format [cos(theta), sin(theta)]
+    # * *Raises* :
+    #   - +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
 
-      return [xx,yy]
+      ::NMatrix::BLAS.cblas_rotg(ab)
     end
 
+
     #
     # call-seq:
-    #     asum(x, incx, n)
+    #     asum(x, incx, n) -> Numeric
     #
     # Calculate the sum of absolute values of the entries of a vector +x+ of size +n+
     #