nmatrix 0.0.1 → 0.0.2

data/ext/nmatrix/util/sl_list.h

@@ -0,0 +1,255 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// 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 - 2012, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == sl_list.h
+//
+// Singly-linked list implementation used for List Storage.
+
+#ifndef SL_LIST_H
+#define SL_LIST_H
+
+
+/*
+ * Standard Includes
+ */
+
+#include <type_traits>
+#include <cstdlib>
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+#include "data/data.h"
+
+#include "nmatrix.h"
+
+namespace nm { namespace list {
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+ 
+
+/*
+ * Functions
+ */
+ 
+////////////////
+// Lifecycle //
+///////////////
+
+LIST*	create(void);
+void	del(LIST* list, size_t recursions);
+void	mark(LIST* list, size_t recursions);
+
+///////////////
+// Accessors //
+///////////////
+
+NODE* insert(LIST* list, bool replace, size_t key, void* val);
+NODE* insert_with_copy(LIST *list, size_t key, void *val, size_t size);
+NODE* insert_after(NODE* node, size_t key, void* val);
+void* remove(LIST* list, size_t key);
+bool remove_recursive(LIST* list, const size_t* coords, const size_t* offset, size_t r, const size_t& dim, void* rm);
+
+template <typename Type>
+inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type val) {
+	Type* val_mem = 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);
+	}
+}
+
+///////////
+// 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 //
+/////////////
+
+NODE* find(LIST* list, size_t key);
+NODE* find_preceding_from(NODE* prev, size_t key);
+NODE* find_nearest(LIST* list, size_t key);
+NODE* find_nearest_from(NODE* prev, size_t key);
+
+/////////////////////////
+// Copying and Casting //
+/////////////////////////
+
+template <typename LDType, typename RDType>
+void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursions);
+
+}} // end of namespace nm::list
+
+extern "C" {
+  void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, dtype_t lhs_dtype, dtype_t rhs_dtype, size_t recursions);
+  VALUE nm_list_copy_to_hash(const LIST* l, const dtype_t dtype, size_t recursions, VALUE default_value);
+} // end of extern "C" block
+
+#endif // SL_LIST_H

data/ext/nmatrix/util/util.h

@@ -0,0 +1,78 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// 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 - 2012, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == util.h
+//
+// Header file for utility functions and data.
+
+#ifndef UTIL_H
+#define UTIL_H
+
+/*
+ * Standard Includes
+ */
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+
+/*
+ * Functions
+ */
+namespace nm {
+  template <typename Type>
+  inline Type gcf(Type x, Type y) {
+    Type t;
+
+    if (x < 0) x = -x;
+    if (y < 0) y = -y;
+
+    if (x == 0) return y;
+    if (y == 0) return x;
+
+    while (x > 0) {
+      t = x;
+      x = y % x;
+      y = t;
+    }
+
+    return y;
+  }
+} // end of namespace nm
+
+
+#endif // UTIL_H

data/lib/nmatrix/blas.rb

@@ -0,0 +1,70 @@
+module NMatrix::BLAS
+
+  class << self
+
+    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)
+
+    	# First, set m, n, and k, which depend on whether we're taking the
+    	# transpose of a and b.
+    	if c
+    		m ||= c.shape[0]
+    		n ||= c.shape[1]
+    		k ||= transpose_a ? a.shape[0] : a.shape[1]
+
+    	else
+    		if transpose_a
+    			# Either :transpose or :complex_conjugate.
+    			m ||= a.shape[1]
+    			k ||= a.shape[0]
+
+    		else
+    			# No transpose.
+    			m ||= a.shape[0]
+    			k ||= a.shape[1]
+    		end
+
+    		n ||= transpose_b ? b.shape[0] : b.shape[1]
+    		c		= NMatrix.new([m, n], a.dtype)
+    	end
+
+    	# I think these are independent of whether or not a transpose occurs.
+    	lda ||= a.shape[1]
+    	ldb ||= b.shape[1]
+    	ldc ||= c.shape[1]
+
+    	# NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
+    	if a.dtype == :complex64 or a.dtype == :complex128
+    		alpha = Complex.new(1.0, 0.0) if alpha == 1.0
+    		beta  = Complex.new(0.0, 0.0) if beta  == 0.0
+    	end
+
+    	# For argument descriptions, see: http://www.netlib.org/blas/dgemm.f
+    	::NMatrix::BLAS.cblas_gemm(:row, transpose_a, transpose_b, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
+
+    	return c
+    end
+
+    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)
+    	m ||= transpose_a ? a.shape[1] : a.shape[0]
+    	n ||= transpose_a ? a.shape[0] : a.shape[1]
+
+    	lda		||= a.shape[1]
+    	incx	||= 1
+    	incy	||= 1
+
+    	# NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
+    	if a.dtype == :complex64 or a.dtype == :complex128
+    		alpha = Complex.new(1.0, 0.0) if alpha == 1.0
+    		beta  = Complex.new(0.0, 0.0) if beta  == 0.0
+    	end
+
+    	::NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
+
+    	return y
+    end
+
+  end
+end