nmatrix-atlas 0.2.0

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

@@ -0,0 +1,202 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 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.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == yale.h
+//
+// "new yale" storage format for 2D matrices (like yale, but with
+// the diagonal pulled out for O(1) access).
+//
+// Specifications:
+// * dtype and index dtype must necessarily differ
+//      * index dtype is defined by whatever unsigned type can store
+//        max(rows,cols)
+//      * that means vector ija stores only index dtype, but a stores
+//        dtype
+// * vectors must be able to grow as necessary
+//      * maximum size is rows*cols+1
+
+#ifndef YALE_H
+#define YALE_H
+
+/*
+ * Standard Includes
+ */
+
+#include <limits> // for std::numeric_limits<T>::max()
+#include <stdexcept>
+
+/*
+ * Project Includes
+ */
+
+#include "../../types.h"
+#include "../../data/data.h"
+#include "../common.h"
+#include "../../nmatrix.h"
+
+extern "C" {
+
+  /*
+   * Macros
+   */
+
+  #ifndef NM_CHECK_ALLOC
+   #define NM_CHECK_ALLOC(x) if (!x) rb_raise(rb_eNoMemError, "insufficient memory");
+  #endif
+
+  /*
+   * Types
+   */
+
+
+  /*
+   * Data
+   */
+
+
+  /*
+   * Functions
+   */
+
+  ///////////////
+  // Lifecycle //
+  ///////////////
+
+  YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity);
+  YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* shape, char* ia, char* ja, char* 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_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 //
+  ///////////////
+
+  VALUE nm_yale_each_with_indices(VALUE nmatrix);
+  VALUE nm_yale_each_stored_with_indices(VALUE nmatrix);
+  VALUE nm_yale_stored_diagonal_each_with_indices(VALUE nmatrix);
+  VALUE nm_yale_stored_nondiagonal_each_with_indices(VALUE nmatrix);
+  VALUE nm_yale_each_ordered_stored_with_indices(VALUE nmatrix);
+  void* nm_yale_storage_get(const STORAGE* s, SLICE* slice);
+  void*	nm_yale_storage_ref(const STORAGE* s, SLICE* slice);
+  void  nm_yale_storage_set(VALUE left, SLICE* slice, VALUE right);
+
+  //char  nm_yale_storage_vector_insert(YALE_STORAGE* s, size_t pos, size_t* js, void* vals, size_t n, bool struct_only, nm::dtype_t dtype, nm::itype_t itype);
+  //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 //
+  ///////////
+
+  bool nm_yale_storage_eqeq(const STORAGE* left, const STORAGE* right);
+
+  //////////
+  // Math //
+  //////////
+
+  STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
+
+  /////////////
+  // Utility //
+  /////////////
+
+
+
+  /////////////////////////
+  // Copying and Casting //
+  /////////////////////////
+
+  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
+
+namespace nm {
+
+namespace yale_storage {
+
+  /*
+   * Typedefs
+   */
+
+  typedef size_t IType;
+
+
+  /*
+   * Templated Functions
+   */
+
+  int binary_search(YALE_STORAGE* s, IType left, IType right, IType key);
+
+  /*
+   * Clear out the D portion of the A vector (clearing the diagonal and setting
+   * 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. 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, void* init_val) {
+    DType* a = reinterpret_cast<DType*>(s->a);
+
+    // Clear out the diagonal + one extra entry
+    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>
+  void init(YALE_STORAGE* s, void* init_val);
+
+  size_t  get_size(const YALE_STORAGE* storage);
+
+  IType binary_search_left_boundary(const YALE_STORAGE* s, IType left, IType right, IType bound);
+
+
+}} // end of namespace nm::yale_storage
+
+#endif // YALE_H

data/ext/nmatrix/types.h

@@ -0,0 +1,54 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 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.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == types.h
+//
+// Definition of simple types used throughout NMatrix.
+
+#ifndef NMATRIX_TYPES_H
+#define NMATRIX_TYPES_H
+
+/*
+ * Standard Includes
+ */
+
+#include <cstdint>
+
+/*
+ * Macros
+ */
+
+#define EPSILON 1E-10
+#define FP_IS_ZERO(n) (-EPSILON < n && n < EPSILON)
+#define FP_EQUAL(a, b) FP_IS_ZERO((a - b))
+
+/*
+ * Types
+ */
+
+typedef float		float32_t;
+typedef double	float64_t;
+
+typedef size_t  IType;
+
+#endif

data/ext/nmatrix/util/io.h

@@ -0,0 +1,115 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 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.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == io.h
+//
+// Header file for input/output support functions.
+
+#ifndef NMATRIX_IO_H
+#define NMATRIX_IO_H
+
+/*
+ * Project Includes
+ */
+
+#include "nmatrix.h"
+
+#include "data/data.h"
+#include "storage/storage.h"
+
+/*
+ * Extern Types
+ */
+extern const char* const DTYPE_NAMES[nm::NUM_DTYPES];
+
+namespace nm { namespace io {
+  /*
+   * Types
+   */
+  enum matlab_dtype_t {
+    miINT8 = 1,
+    miUINT8 = 2,
+    miINT16 = 3,
+    miUINT16 = 4,
+    miINT32 = 5,
+    miUINT32 = 6,
+    miSINGLE = 7,
+    miDOUBLE = 9,
+    miINT64 = 12,
+    miUINT64 = 13,
+    miMATRIX = 14
+  };
+
+  /*
+   * Constants
+   */
+
+  const size_t NUM_MATLAB_DTYPES = 15;
+}} // end of namespace nm::io
+
+extern "C" {
+
+  /*
+   * C accessors.
+   */
+  nm::dtype_t nm_dtype_from_rbsymbol(VALUE sym);
+  nm::dtype_t nm_dtype_from_rbstring(VALUE str);
+  nm::stype_t nm_stype_from_rbsymbol(VALUE sym);
+  nm::stype_t nm_stype_from_rbstring(VALUE str);
+
+  void nm_init_io(void);
+
+
+  /*
+   * Macros.
+   */
+
+  /*
+   * Macro for a function pointer table between NMatrix dtypes and MATLAB dtypes.
+   *
+   * You can't convert as freely between these two as you can between NMatrix dtypes, but there's no reason to. MATLAB
+   * stores its complex numbers in two separate arrays, for example, not as a single unit of data. If you want to convert
+   * to a VALUE, convert first to an appropriate integer or float type.
+   *
+   * FIXME: Maybe be a little more selective about which conversions we DO allow. This is really just for loading an
+   * already-constructed MATLAB matrix into memory, and most of these functions will never get called.
+   */
+  #define NM_MATLAB_DTYPE_TEMPLATE_TABLE(name,fun,ret,...)    \
+  static ret (*(name)[7][nm::io::NUM_MATLAB_DTYPES])(__VA_ARGS__) = {  \
+      { NULL, fun<uint8_t,int8_t>, fun<uint8_t,uint8_t>, fun<uint8_t,int16_t>, fun<uint8_t,uint16_t>, fun<uint8_t,int32_t>, fun<uint8_t,uint32_t>, fun<uint8_t,float>, NULL, fun<uint8_t,double>, NULL, NULL, fun<uint8_t,int64_t>, fun<uint8_t,uint64_t>, NULL },  \
+      { NULL, fun<int8_t,int8_t>, fun<int8_t,uint8_t>, fun<int8_t,int16_t>, fun<int8_t,uint16_t>, fun<int8_t,int32_t>, fun<int8_t,uint32_t>, fun<int8_t,float>, NULL, fun<int8_t,double>, NULL, NULL, fun<int8_t,int64_t>, fun<int8_t,uint64_t>, NULL },            \
+      { NULL, fun<int16_t,int8_t>, fun<int16_t,uint8_t>, fun<int16_t,int16_t>, fun<int16_t,uint16_t>, fun<int16_t,int32_t>, fun<int16_t,uint32_t>, fun<int16_t,float>, NULL, fun<int16_t,double>, NULL, NULL, fun<int16_t,int64_t>, fun<int16_t,uint64_t>, NULL },  \
+      { NULL, fun<int32_t,int8_t>, fun<int32_t,uint8_t>, fun<int32_t,int16_t>, fun<int32_t,uint16_t>, fun<int32_t,int32_t>, fun<int32_t,uint32_t>, fun<int32_t,float>, NULL, fun<int32_t,double>, NULL, NULL, fun<int32_t,int64_t>, fun<int32_t,uint64_t>, NULL },  \
+      { NULL, fun<int64_t,int8_t>, fun<int64_t,uint8_t>, fun<int64_t,int16_t>, fun<int64_t,uint16_t>, fun<int64_t,int32_t>, fun<int64_t,uint32_t>, fun<int64_t,float>, NULL, fun<int64_t,double>, NULL, NULL, fun<int64_t,int64_t>, fun<int64_t,uint64_t>, NULL },  \
+      { NULL, fun<float,int8_t>, fun<float,uint8_t>, fun<float,int16_t>, fun<float,uint16_t>, fun<float,int32_t>, fun<float,uint32_t>, fun<float,float>, NULL, fun<float,double>, NULL, NULL, fun<float,int64_t>, fun<float,uint64_t>, NULL },                      \
+      { NULL, fun<double,int8_t>, fun<double,uint8_t>, fun<double,int16_t>, fun<double,uint16_t>, fun<double,int32_t>, fun<double,uint32_t>, fun<double,float>, NULL, fun<double,double>, NULL, NULL, fun<double,int64_t>, fun<double,uint64_t>, NULL }             \
+    };
+
+  /*
+   * Hash#has_key? for symbols. Arguments are: hash (VALUE), string (char*).
+   */
+  #define RB_HASH_HAS_SYMBOL_KEY(hash, str)   (rb_funcall((hash), rb_intern("has_key?"), 1, ID2SYM(rb_intern(str))) == Qtrue)
+}
+
+
+#endif

data/ext/nmatrix/util/sl_list.h

@@ -0,0 +1,143 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 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.
+//
+// == 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_copy(LIST *list, bool replace, size_t key, void *val, size_t size);
+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* insert_after(NODE* node, size_t key, void* val);
+NODE* replace_insert_after(NODE* node, size_t key, void* val, bool copy, size_t copy_size);
+void* remove(LIST* list, size_t key);
+void* remove_by_node(LIST* list, NODE* prev, NODE* rm);
+bool remove_recursive(LIST* list, const size_t* coords, const size_t* offset, const size_t* lengths, size_t r, const size_t& dim);
+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);
+	}
+}
+
+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 //
+///////////
+
+
+/////////////
+// Utility //
+/////////////
+
+NODE* find(LIST* list, size_t key);
+NODE* find_preceding_from_node(NODE* prev, size_t key);
+NODE* find_preceding_from_list(LIST* l, 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, nm::dtype_t lhs_dtype, nm::dtype_t rhs_dtype, size_t recursions);
+  VALUE nm_list_copy_to_hash(const LIST* l, const nm::dtype_t dtype, size_t recursions, VALUE default_value);
+} // end of extern "C" block
+
+#endif // SL_LIST_H