nmatrix-fftw 0.2.1

data/ext/nmatrix/ruby_constants.h

@@ -0,0 +1,106 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == data.h
+//
+// Header file for dealing with data types.
+
+#ifndef RUBY_CONSTANTS_H
+#define RUBY_CONSTANTS_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+
+/*
+ * Data
+ */
+
+extern ID nm_rb_dtype,
+          nm_rb_stype,
+
+          nm_rb_capacity,
+          nm_rb_default,
+
+          nm_rb_real,
+          nm_rb_imag,
+
+          nm_rb_numer,
+          nm_rb_denom,
+
+          nm_rb_complex_conjugate,
+          nm_rb_transpose,
+          nm_rb_no_transpose,
+          nm_rb_left,
+          nm_rb_right,
+          nm_rb_upper,
+          nm_rb_lower,
+          nm_rb_unit,
+          nm_rb_nonunit,
+
+          nm_rb_dense,
+          nm_rb_list,
+          nm_rb_yale,
+
+          nm_rb_row,
+          nm_rb_column,
+
+          nm_rb_add,
+          nm_rb_sub,
+          nm_rb_mul,
+          nm_rb_div,
+
+          nm_rb_negate,
+
+          nm_rb_percent,
+          nm_rb_gt,
+          nm_rb_lt,
+          nm_rb_eql,
+          nm_rb_neql,
+          nm_rb_gte,
+          nm_rb_lte,
+
+          nm_rb_hash;
+
+extern VALUE  cNMatrix,
+              cNMatrix_IO,
+              cNMatrix_IO_Matlab,
+              cNMatrix_YaleFunctions,
+
+              cNMatrix_GC_holder,
+
+              nm_eDataTypeError,
+              nm_eConvergenceError,
+              nm_eStorageTypeError,
+              nm_eShapeError,
+              nm_eNotInvertibleError;
+
+/*
+ * Functions
+ */
+
+void nm_init_ruby_constants(void);
+
+#endif // RUBY_CONSTANTS_H

data/ext/nmatrix/storage/common.h

@@ -0,0 +1,177 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == common.h
+//
+// Header file for code common to all storage types.
+
+#ifndef STORAGE_COMMON_H
+#define STORAGE_COMMON_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <cmath> // pow().
+
+/*
+ * Project Includes
+ */
+#include "data/data.h"
+#include "nmatrix.h"
+
+/*
+ * Macros
+ */
+
+extern "C" {
+
+/*
+ * Types
+ */
+
+// For binary operations involving matrices that need to be casted.
+struct STORAGE_PAIR {
+  STORAGE* left;
+  STORAGE* right;
+};
+
+struct SLICE {
+  size_t*  coords; // Coordinate of first element
+  size_t*  lengths; // Lengths of slice
+  bool    single; // true if all lengths equal to 1 (represents single matrix element)
+};
+
+/*
+ * Data
+ */
+
+/*
+ * Functions
+ */
+
+  size_t nm_storage_count_max_elements(const STORAGE* storage);
+  VALUE nm_enumerator_length(VALUE nmatrix);
+
+} // end of extern "C" block
+
+namespace nm {
+
+  /*
+   * Templated helper function for element-wise operations, used by dense, yale, and list.
+   */
+  template <ewop_t op, typename LDType, typename RDType>
+  inline VALUE ew_op_switch(LDType left, RDType right) {
+    switch (op) {
+      case EW_ADD:
+        return RubyObject(left + right).rval;
+
+      case EW_SUB:
+        return RubyObject(left - right).rval;
+
+      case EW_MUL:
+        return RubyObject(left * right).rval;
+
+      case EW_DIV:
+        return RubyObject(left / right).rval;
+
+      case EW_POW:
+        return RubyObject(pow(left, right)).rval;
+
+      case EW_MOD:
+        rb_raise(rb_eNotImpError, "Element-wise modulo is currently not supported.");
+        break;
+
+      default:
+        rb_raise(rb_eStandardError, "This should not happen.");
+    }
+    return Qnil;
+  }
+
+  #define EWOP_INT_INT_DIV(ltype, rtype)       template <>       \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+    if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
+    if ((left > 0 && right > 0) || (left < 0 && right < 0)) \
+      return left / right;  \
+    else \
+      return ( ltype )(std::floor((double)(left) / (double)(right)));  \
+  }
+
+  #define EWOP_UINT_UINT_DIV(ltype, rtype)       template <>       \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+    if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
+    return left / right;  \
+  }
+
+  #define EWOP_INT_UINT_DIV(ltype, rtype)       template <>       \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+    if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
+    if (left > 0 )  return left / right;  \
+    else            return ( ltype )(std::floor((double)(left) / (double)(right)));  \
+  }
+
+  #define EWOP_UINT_INT_DIV(ltype, rtype)       template <>       \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+    if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
+    if (right > 0)  return left / right;  \
+    else            return ( ltype )(std::floor((double)(left) / (double)(right)));  \
+  }
+
+  #define EWOP_FLOAT_INT_DIV(ltype, rtype)       template <>       \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+    return left / (ltype)(right);  \
+  }
+
+  // Ensure that divisions are done in the Ruby way, and that (int)x/0 always raises a Ruby error instead
+  // of throwing a SIGFPE.
+  EWOP_INT_INT_DIV(int64_t, int64_t)
+  EWOP_INT_INT_DIV(int32_t, int32_t)
+  EWOP_INT_INT_DIV(int32_t, int64_t)
+  EWOP_INT_INT_DIV(int16_t, int16_t)
+  EWOP_INT_INT_DIV(int16_t, int32_t)
+  EWOP_INT_INT_DIV(int16_t, int64_t)
+  EWOP_INT_INT_DIV(int8_t, int8_t)
+  EWOP_INT_UINT_DIV(int8_t, u_int8_t)
+  EWOP_INT_INT_DIV(int8_t, int16_t)
+  EWOP_INT_INT_DIV(int8_t, int32_t)
+  EWOP_INT_INT_DIV(int8_t, int64_t)
+  EWOP_UINT_UINT_DIV(uint8_t, uint8_t)
+  EWOP_UINT_INT_DIV(uint8_t, int8_t)
+  EWOP_UINT_INT_DIV(uint8_t, int16_t)
+  EWOP_UINT_INT_DIV(uint8_t, int32_t)
+  EWOP_UINT_INT_DIV(uint8_t, int64_t)
+  EWOP_FLOAT_INT_DIV(float, int8_t)
+  EWOP_FLOAT_INT_DIV(float, u_int8_t)
+  EWOP_FLOAT_INT_DIV(float, int16_t)
+  EWOP_FLOAT_INT_DIV(float, int32_t)
+  EWOP_FLOAT_INT_DIV(float, int64_t)
+  EWOP_FLOAT_INT_DIV(double, int8_t)
+  EWOP_FLOAT_INT_DIV(double, u_int8_t)
+  EWOP_FLOAT_INT_DIV(double, int16_t)
+  EWOP_FLOAT_INT_DIV(double, int32_t)
+  EWOP_FLOAT_INT_DIV(double, int64_t)
+
+}
+
+#endif // STORAGE_COMMON_H

data/ext/nmatrix/storage/dense/dense.h

@@ -0,0 +1,129 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == dense.h
+//
+// Dense n-dimensional matrix storage.
+
+#ifndef DENSE_H
+#define DENSE_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <cstdlib>
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+//#include "util/math.h"
+
+#include "data/data.h"
+
+#include "../common.h"
+
+#include "nmatrix.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+
+extern "C" {
+
+/*
+ * Functions
+ */
+
+///////////////
+// Lifecycle //
+///////////////
+
+DENSE_STORAGE*  nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length);
+void            nm_dense_storage_delete(STORAGE* s);
+void            nm_dense_storage_delete_ref(STORAGE* s);
+void            nm_dense_storage_mark(STORAGE*);
+void            nm_dense_storage_register(const STORAGE* s);
+void            nm_dense_storage_unregister(const STORAGE* s);
+
+
+///////////////
+// Accessors //
+///////////////
+
+
+VALUE nm_dense_map_pair(VALUE self, VALUE right);
+VALUE nm_dense_map(VALUE self);
+VALUE nm_dense_each(VALUE nmatrix);
+VALUE nm_dense_each_with_indices(VALUE nmatrix);
+void*  nm_dense_storage_get(const STORAGE* s, SLICE* slice);
+void*  nm_dense_storage_ref(const STORAGE* s, SLICE* slice);
+void  nm_dense_storage_set(VALUE left, SLICE* slice, VALUE right);
+
+///////////
+// Tests //
+///////////
+
+bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right);
+bool nm_dense_storage_is_symmetric(const DENSE_STORAGE* mat, int lda);
+bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda);
+
+//////////
+// Math //
+//////////
+
+STORAGE* nm_dense_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
+
+/////////////
+// Utility //
+/////////////
+
+size_t nm_dense_storage_pos(const DENSE_STORAGE* s, const size_t* coords);
+void nm_dense_storage_coords(const DENSE_STORAGE* s, const size_t slice_pos, size_t* coords_out);
+
+/////////////////////////
+// Copying and Casting //
+/////////////////////////
+
+DENSE_STORAGE*  nm_dense_storage_copy(const DENSE_STORAGE* rhs);
+STORAGE*        nm_dense_storage_copy_transposed(const STORAGE* rhs_base);
+STORAGE*        nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype, void*);
+
+} // end of extern "C" block
+
+namespace nm {
+  std::pair<NMATRIX*,bool> interpret_arg_as_dense_nmatrix(VALUE right, nm::dtype_t dtype);
+} // end of namespace nm
+
+#endif // DENSE_H

data/ext/nmatrix/storage/list/list.h

@@ -0,0 +1,138 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == list.h
+//
+// List-of-lists n-dimensional matrix storage. Uses singly-linked
+// lists.
+
+#ifndef LIST_H
+#define LIST_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <cstdlib>
+#include <list>
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+#include "data/data.h"
+#include "../common.h"
+#include "util/sl_list.h"
+#include "nmatrix.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+
+
+/*
+ * Data
+ */
+ 
+extern "C" {
+
+  /*
+   * Functions
+   */
+
+  ////////////////
+  // Lifecycle //
+  ///////////////
+
+  LIST_STORAGE*  nm_list_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* init_val);
+  void          nm_list_storage_delete(STORAGE* s);
+  void          nm_list_storage_delete_ref(STORAGE* s);
+  void          nm_list_storage_mark(STORAGE*);
+  void          nm_list_storage_register(const STORAGE* s);
+  void          nm_list_storage_unregister(const STORAGE* s);
+  void          nm_list_storage_register_list(const LIST* l, size_t recursions);
+  void          nm_list_storage_unregister_list(const LIST* l, size_t recursions);
+  void          nm_list_storage_register_node(const NODE* n);
+  void          nm_list_storage_unregister_node(const NODE* n);
+  void          nm_list_storage_completely_unregister_node(const NODE* curr);
+  ///////////////
+  // Accessors //
+  ///////////////
+
+  VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored);
+  void* nm_list_storage_ref(const STORAGE* s, SLICE* slice);
+  void* nm_list_storage_get(const STORAGE* s, SLICE* slice);
+  NODE* nm_list_storage_insert(STORAGE* s, SLICE* slice, void* val);
+  void  nm_list_storage_set(VALUE left, SLICE* slice, VALUE right);
+  void  nm_list_storage_remove(STORAGE* s, SLICE* slice);
+
+  ///////////
+  // Tests //
+  ///////////
+
+  bool nm_list_storage_eqeq(const STORAGE* left, const STORAGE* right);
+
+  //////////
+  // Math //
+  //////////
+
+  STORAGE* nm_list_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
+
+
+  /////////////
+  // Utility //
+  /////////////
+
+  size_t nm_list_storage_count_elements_r(const LIST* l, size_t recursions);
+  size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s);
+
+  /*
+   * Count non-zero elements. See also count_list_storage_nd_elements.
+   */
+  inline size_t nm_list_storage_count_elements(const LIST_STORAGE* s) {
+    return nm_list_storage_count_elements_r(s->rows, s->dim - 1);
+  }
+
+  /////////////////////////
+  // Copying and Casting //
+  /////////////////////////
+
+  LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs);
+  STORAGE*      nm_list_storage_copy_transposed(const STORAGE* rhs_base);
+  STORAGE*      nm_list_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype, void*);
+  VALUE         nm_list_storage_to_hash(const LIST_STORAGE* s, const nm::dtype_t dtype);
+
+  // Exposed functions
+  VALUE nm_to_hash(VALUE self);
+  VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init);
+  VALUE nm_list_map_stored(VALUE left, VALUE init);
+  VALUE nm_list_default_value(VALUE self);
+} // end of extern "C" block
+
+#endif // LIST_H