nmatrix 0.0.1 → 0.0.2

data/ext/nmatrix/storage/yale.h

@@ -0,0 +1,208 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == 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()
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+#include "data/data.h"
+
+#include "common.h"
+
+#include "nmatrix.h"
+
+extern "C" {
+
+  /*
+   * Macros
+   */
+
+  #define NM_YALE_MINIMUM(sptr)               (((YALE_STORAGE*)(sptr))->shape[0]*2 + 1) // arbitrarily defined
+
+  #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(dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity);
+  YALE_STORAGE* nm_yale_storage_create_from_old_yale(dtype_t dtype, size_t* shape, void* ia, void* ja, void* a, 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_mark(void*);
+
+  ///////////////
+  // Accessors //
+  ///////////////
+
+  void* nm_yale_storage_get(STORAGE* s, SLICE* slice);
+  void*	nm_yale_storage_ref(STORAGE* s, SLICE* slice);
+  char  nm_yale_storage_set(STORAGE* storage, SLICE* slice, void* v);
+
+  inline size_t  nm_yale_storage_get_size(const YALE_STORAGE* storage);
+
+  ///////////
+  // Tests //
+  ///////////
+
+  bool nm_yale_storage_eqeq(const STORAGE* left, const STORAGE* right);
+
+  //////////
+  // Math //
+  //////////
+	
+	STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right);
+  STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
+
+  /////////////
+  // Utility //
+  /////////////
+
+  /*
+   * Calculates the itype a YALE_STORAGE object would need without actually needing
+   * to see the YALE_STORAGE object. Does this just by looking at the shape.
+   *
+   * Useful for creating Yale Storage by other means than NMatrix.new(:yale, ...),
+   * e.g., from a MATLAB v5 .mat file.
+   */
+  inline itype_t nm_yale_storage_itype_by_shape(const size_t* shape) {
+    uint64_t yale_max_size = shape[0] * (shape[1]+1);
+
+    if (yale_max_size < static_cast<uint64_t>(std::numeric_limits<uint8_t>::max()) - 2) {
+      return UINT8;
+
+    } else if (yale_max_size < static_cast<uint64_t>(std::numeric_limits<uint16_t>::max()) - 2) {
+      return UINT16;
+
+    } else if (yale_max_size < std::numeric_limits<uint32_t>::max() - 2) {
+      return UINT32;
+
+    } else {
+      return UINT64;
+    }
+  }
+
+  /*
+   * Determine the index dtype (which will be used for the ija vector). This is
+   * determined by matrix shape, not IJA/A vector capacity. Note that it's MAX-2
+   * because UINTX_MAX and UINTX_MAX-1 are both reserved for sparse matrix
+   * multiplication.
+   */
+  inline itype_t nm_yale_storage_itype(const YALE_STORAGE* s) {
+    return nm_yale_storage_itype_by_shape(s->shape);
+  }
+
+
+  /////////////////////////
+  // Copying and Casting //
+  /////////////////////////
+
+  STORAGE*      nm_yale_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype);
+  STORAGE*      nm_yale_storage_copy_transposed(const STORAGE* rhs_base);
+
+
+
+  void nm_init_yale_functions(void);
+
+
+} // end of extern "C" block
+
+namespace nm { namespace yale_storage {
+
+  /*
+   * Constants
+   */
+  const float GROWTH_CONSTANT = 1.5;
+
+
+  /*
+   * Templated Functions
+   */
+
+  template <typename IType>
+  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.
+   */
+  template <typename DType>
+  inline void clear_diagonal_and_zero(YALE_STORAGE* s) {
+    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;
+  }
+
+  template <typename DType, typename IType>
+  void init(YALE_STORAGE* s);
+
+}} // end of namespace nm::yale_storage
+
+#endif // YALE_H

data/ext/nmatrix/ttable_helper.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/ruby
+
+# A helper file for generating and maintaining template tables.
+
+def nullify(disabled)
+	DTYPES.map { |t| if disabled.include?(t) then :NULL else t end }
+end
+
+DTYPES = [
+	:uint8_t,
+	:int8_t,
+	:int16_t,
+	:int32_t,
+	:int64_t,
+	:float32_t,
+	:float64_t,
+	:'nm::Complex64',
+	:'nm::Complex128',
+	:'nm::Rational32',
+	:'nm::Rational64',
+	:'nm::Rational128',
+	:'nm::RubyObject'
+]
+
+ITYPES = [
+	:uint8_t,
+	:uint16_t,
+	:uint32_t,
+	:uint64_t
+]
+
+EWOPS = [
+	:'nm::EW_ADD',
+	:'nm::EW_SUB',
+	:'nm::EW_MUL',
+	:'nm::EW_DIV',
+	:'nm::EW_MOD',
+  :'nm::EW_EQEQ',
+  :'nm::EW_NEQ',
+  :'nm::EW_LT',
+  :'nm::EW_GT',
+  :'nm::EW_LEQ',
+  :'nm::EW_GEQ'
+]
+
+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])
+}
+
+lines =
+case ARGV[0]
+when 'OPLR'
+	'{' +
+	EWOPS.map do |op|
+	
+		'{' +
+		DTYPES.map do |l_dtype|
+		
+			'{' +
+			LR_ALLOWED[l_dtype].map do |r_dtype|
+				if r_dtype == :NULL
+					'NULL'
+				else
+					"fun<#{op}, #{l_dtype}, #{r_dtype}>"
+				end
+			end.join(', ') +
+			'}'
+		
+		end.join(",\n") +
+		'}'
+	
+	end.join(",\n") +
+	'}'
+
+when 'OPID'
+	'{' +
+	EWOPS.map do |op|
+		'{' +
+		ITYPES.map do |itype|
+			'{' +
+			DTYPES.map do |dtype|
+			
+				if dtype == :NULL
+					'NULL'
+				else
+					"fun<#{op}, #{itype}, #{dtype}>"
+				end
+		
+			end.join(",") +
+			'}'
+		end.join(",\\\n") +
+		'}'
+	end.join(",\\\n") +
+	'}'
+
+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") +
+		'}'
+end
+
+puts lines

data/ext/nmatrix/{yale/smmp1_header.template.c → types.h}

@@ -21,18 +21,45 @@
 //
 // * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
 //
-// == smmp1.c
+// == types.h
 //
-// smmp1.c is automatically generated by generator.rb. Do not modify
-// it directly!
-//
-// This file ensures that all SMMP functions have the same signature,
-// so we can call them using arrays of function pointers.
+// Definition of simple types used throughout NMatrix.
+
+#ifndef NMATRIX_TYPES_H
+#define NMATRIX_TYPES_H
+
+/*
+ * Standard Includes
+ */
+
+#include <stdint.h>
+
+/*
+ * Project Includes
+ */
+
+/*
+ * 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
+ */
 
-#include "nmatrix.h"
+typedef float		float32_t;
+typedef double	float64_t;
 
-#include <stdlib.h>
-#include <stdio.h>
 
+/*
+ * Data
+ */
 
+/*
+ * Functions
+ */
 
+#endif

data/ext/nmatrix/util/io.cpp

@@ -0,0 +1,295 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == io.cpp
+//
+// Input/output support functions.
+
+#include "io.h"
+
+#include <ruby.h>
+
+namespace nm { namespace io {
+
+  const char* const MATLAB_DTYPE_NAMES[NUM_MATLAB_DTYPES] = {
+    "miUNDEFINED0",
+    "miINT8",
+    "miUINT8",
+    "miINT16",
+    "miUINT16",
+    "miINT32",
+    "miUINT32",
+    "miSINGLE",
+    "miRESERVED8",
+    "miDOUBLE",
+    "miRESERVED10",
+    "miRESERVED11",
+    "miINT64",
+    "miUINT64",
+    "miMATRIX"
+  };
+
+  const size_t MATLAB_DTYPE_SIZES[NUM_MATLAB_DTYPES] = {
+    1, // undefined
+    1, // int8
+    1, // uint8
+    2, // int16
+    2, // uint16
+    4, // int32
+    4, // uint32
+    sizeof(float),
+    1, // reserved
+    sizeof(double),
+    1, // reserved
+    1, // reserved
+    8, // int64
+    8, // uint64
+    1  // matlab array?
+  };
+
+
+/*
+ * Templated function for converting from MATLAB dtypes to NMatrix dtypes.
+ */
+template <typename DType, typename MDType>
+char* matlab_cstring_to_dtype_string(size_t& result_len, const char* str, size_t bytes) {
+
+  result_len   = bytes / sizeof(DType);
+  char* result = ALLOC_N(char, bytes / sizeof(DType));
+
+  if (bytes % sizeof(MDType) != 0) {
+    rb_raise(rb_eArgError, "the given string does not divide evenly for the given MATLAB dtype");
+  }
+
+  for (size_t i = 0, j = 0; i < bytes; i += sizeof(MDType), j += sizeof(DType)) {
+    *reinterpret_cast<DType*>(result+j) = (DType)(*reinterpret_cast<const MDType*>(str + i));
+  }
+
+  return result;
+}
+
+}} // end of namespace nm::io
+
+extern "C" {
+
+///////////////////////
+// Utility Functions //
+///////////////////////
+
+/*
+ * Converts a string to a data type.
+ */
+dtype_t nm_dtype_from_rbstring(VALUE str) {
+
+  for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
+  	if (!std::strncmp(RSTRING_PTR(str), DTYPE_NAMES[index], RSTRING_LEN(str))) {
+  		return static_cast<dtype_t>(index);
+  	}
+  }
+
+  rb_raise(rb_eArgError, "Invalid data type string specified.");
+}
+
+
+/*
+ * Converts a symbol to a data type.
+ */
+dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
+
+  for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
+    if (SYM2ID(sym) == rb_intern(DTYPE_NAMES[index])) {
+    	return static_cast<dtype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid data type symbol specified.");
+}
+
+
+/*
+ * Converts a symbol to an index type.
+ */
+itype_t nm_itype_from_rbsymbol(VALUE sym) {
+
+  for (size_t index = 0; index < NM_NUM_ITYPES; ++index) {
+    if (SYM2ID(sym) == rb_intern(ITYPE_NAMES[index])) {
+    	return static_cast<itype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid index type specified.");
+}
+
+/*
+ * Converts a string to a storage type. Only looks at the first three
+ * characters.
+ */
+stype_t nm_stype_from_rbstring(VALUE str) {
+
+  for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
+    if (!std::strncmp(RSTRING_PTR(str), STYPE_NAMES[index], 3)) {
+    	return static_cast<stype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid storage type string specified");
+  return DENSE_STORE;
+}
+
+/*
+ * Converts a symbol to a storage type.
+ */
+stype_t nm_stype_from_rbsymbol(VALUE sym) {
+
+  for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
+    if (SYM2ID(sym) == rb_intern(STYPE_NAMES[index])) {
+    	return static_cast<stype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid storage type symbol specified");
+  return DENSE_STORE;
+}
+
+
+/*
+ * Converts a MATLAB data-type symbol to an enum.
+ */
+static nm::io::matlab_dtype_t matlab_dtype_from_rbsymbol(VALUE sym) {
+  for (size_t index = 0; index < nm::io::NUM_MATLAB_DTYPES; ++index) {
+    if (SYM2ID(sym) == rb_intern(nm::io::MATLAB_DTYPE_NAMES[index])) {
+    	return static_cast<nm::io::matlab_dtype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid matlab type specified.");
+}
+
+
+/*
+ * Take a string of bytes which represent MATLAB data type values and repack them into a string
+ * of bytes representing values of an NMatrix dtype (or itype).
+ *
+ * Returns what appears to be a Ruby String.
+ *
+ * Arguments:
+ * * str        :: the data
+ * * from       :: symbol representing MATLAB data type (e.g., :miINT8)
+ * * options    :: hash, give either :itype => some_itype or :dtype => some_dtype, tells function
+ *                 what to give as output.
+ */
+static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from, VALUE options) {
+  nm::io::matlab_dtype_t from_type = matlab_dtype_from_rbsymbol(from);
+  uint8_t to_type;
+
+  if (TYPE(options) != T_HASH) {
+    rb_raise(rb_eArgError, "third argument to repack must be an options hash");
+  }
+
+  if (RB_HASH_HAS_SYMBOL_KEY(options, "dtype")) { // Hash#has_key?(:dtype)
+
+    dtype_t to_dtype  = nm_dtype_from_rbsymbol(rb_hash_aref(options, ID2SYM(rb_intern("dtype"))));
+    to_type           = static_cast<int8_t>(to_dtype);
+
+  } else if (RB_HASH_HAS_SYMBOL_KEY(options, "itype")) {
+
+    itype_t to_itype  = nm_itype_from_rbsymbol(rb_hash_aref(options, ID2SYM(rb_intern("itype"))));
+
+    // we're going to cheat and use the DTYPE template table. To do this, we just act like uint8_t
+    // is a dtype (both are 0, itype and dtype), or we add 1 to the other itypes and treat them as
+    // signed.
+    to_type           = static_cast<uint8_t>(to_itype);
+    if (to_itype != UINT8) to_type += 1;
+
+
+  } else {
+    rb_raise(rb_eArgError, "third argument must have either :itype or :dtype as a key");
+  }
+
+  // For next few lines, see explanation above NM_MATLAB_DTYPE_TEMPLATE_TABLE definition in io.h.
+  if (to_type >= static_cast<uint8_t>(COMPLEX64)) {
+    rb_raise(rb_eArgError, "can only repack into a simple dtype, no complex/rational/VALUE");
+  }
+
+  // Do the actual repacking -- really simple!
+  NM_MATLAB_DTYPE_TEMPLATE_TABLE(ttable, nm::io::matlab_cstring_to_dtype_string, char*, size_t& result_len, const char* str, size_t bytes);
+
+  size_t repacked_data_length;
+  char* repacked_data = ttable[to_type][from_type](repacked_data_length, RSTRING_PTR(str), RSTRING_LEN(str));
+
+  // 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);
+  free(repacked_data); // Don't forget to free what we allocated!
+
+  return result;
+}
+
+
+/*
+ * Take two byte-strings (real and imaginary) and treat them as if they contain
+ * a sequence of data of type dtype. Merge them together and return a new string.
+ */
+static VALUE nm_rbstring_merge(VALUE self, VALUE rb_real, VALUE rb_imaginary, VALUE rb_dtype) {
+
+  // Sanity check.
+  if (RSTRING_LEN(rb_real) != RSTRING_LEN(rb_imaginary)) {
+    rb_raise(rb_eArgError, "real and imaginary components do not have same length");
+  }
+
+  dtype_t dtype = nm_dtype_from_rbsymbol(rb_dtype);
+  size_t len    = DTYPE_SIZES[dtype];
+
+  char *real    = RSTRING_PTR(rb_real),
+       *imag    = RSTRING_PTR(rb_imaginary);
+
+  char* merge   = ALLOCA_N(char, RSTRING_LEN(rb_real)*2);
+
+  size_t merge_pos = 0;
+
+  // Merge the two sequences
+  for (size_t i = 0; i < RSTRING_LEN(rb_real); i += len) {
+
+    // Copy real number
+    memcpy(merge + merge_pos, real + i, len);
+    merge_pos += len;
+
+    // Copy imaginary number
+    memcpy(merge + merge_pos, imag + i, len);
+    merge_pos += len;
+  }
+
+  return rb_str_new(merge, merge_pos);
+}
+
+
+void nm_init_io() {
+  cNMatrix_IO = rb_define_module_under(cNMatrix, "IO");
+  cNMatrix_IO_Matlab = rb_define_module_under(cNMatrix_IO, "Matlab");
+
+  rb_define_singleton_method(cNMatrix_IO_Matlab, "repack", (METHOD)nm_rbstring_matlab_repack, 3);
+  rb_define_singleton_method(cNMatrix_IO_Matlab, "complex_merge", (METHOD)nm_rbstring_merge, 3);
+}
+
+
+
+}