nmatrix 0.0.1 → 0.0.2

data/ext/nmatrix/ruby_constants.cpp

@@ -0,0 +1,134 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == ruby_symbols.cpp
+//
+// Ruby symbols used throught the NMatrix project.
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+
+/*
+ * Project Includes
+ */
+
+/*
+ * Macros
+ */
+
+/*
+ * Global Variables
+ */
+
+ID	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_add,
+		nm_rb_sub,
+		nm_rb_mul,
+		nm_rb_div,
+
+		nm_rb_percent,
+		nm_rb_gt,
+		nm_rb_lt,
+		nm_rb_eql,
+		nm_rb_neql,
+		nm_rb_gte,
+		nm_rb_lte;
+
+VALUE cNMatrix,
+      cNMatrix_IO,
+      cNMatrix_IO_Matlab,
+			cNVector,
+			cNMatrix_YaleFunctions,
+			cNMatrix_BLAS,
+			cNMatrix_LAPACK,
+			
+			nm_eDataTypeError,
+			nm_eStorageTypeError;
+
+/*
+ * Forward Declarations
+ */
+
+/*
+ * Functions
+ */
+
+void nm_init_ruby_constants(void) {
+
+	nm_rb_real							= rb_intern("real");
+	nm_rb_imag							= rb_intern("imag");
+
+	nm_rb_numer							= rb_intern("numerator");
+	nm_rb_denom							= rb_intern("denominator");
+
+	nm_rb_complex_conjugate	= rb_intern("complex_conjugate");
+	nm_rb_transpose					= rb_intern("transpose");
+	nm_rb_no_transpose			= rb_intern("no_transpose");
+
+	nm_rb_dense 						= rb_intern("dense");
+	nm_rb_list							= rb_intern("list");
+	nm_rb_yale							= rb_intern("yale");
+
+	nm_rb_add								= rb_intern("+");
+	nm_rb_sub								= rb_intern("-");
+	nm_rb_mul								= rb_intern("*");
+	nm_rb_div								= rb_intern("/");
+
+	nm_rb_percent						= rb_intern("%");
+	nm_rb_gt								= rb_intern(">");
+	nm_rb_lt								= rb_intern("<");
+	nm_rb_eql								= rb_intern("==");
+	nm_rb_neql							= rb_intern("!=");
+	nm_rb_gte								= rb_intern(">=");
+	nm_rb_lte								= rb_intern("<=");
+
+	nm_rb_left              = rb_intern("left");
+	nm_rb_right             = rb_intern("right");
+	nm_rb_upper             = rb_intern("upper");
+	nm_rb_lower             = rb_intern("lower");
+	nm_rb_unit              = rb_intern("unit");
+	nm_rb_nonunit           = rb_intern("nonunit");
+}
+

data/ext/nmatrix/ruby_constants.h

@@ -0,0 +1,103 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == data.h
+//
+// Header file for dealing with data types.
+
+#ifndef RUBY_CONSTANTS_H
+#define RUBY_CONSTANTS_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+
+/*
+ * Project Includes
+ */
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+
+extern ID 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_add,
+					nm_rb_sub,
+					nm_rb_mul,
+					nm_rb_div,
+		
+					nm_rb_percent,
+					nm_rb_gt,
+					nm_rb_lt,
+					nm_rb_eql,
+					nm_rb_neql,
+					nm_rb_gte,
+					nm_rb_lte;
+
+extern VALUE	cNMatrix,
+              cNMatrix_IO,
+              cNMatrix_IO_Matlab,
+							cNVector,
+							cNMatrix_YaleFunctions,
+							cNMatrix_BLAS,
+							cNMatrix_LAPACK,
+			
+							nm_eDataTypeError,
+							nm_eStorageTypeError;
+
+/*
+ * Functions
+ */
+
+void nm_init_ruby_constants(void);
+
+#endif // RUBY_CONSTANTS_H

data/ext/nmatrix/storage/common.cpp

@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == common.cpp
+//
+// Code for the STORAGE struct that is common to all storage types.
+
+/*
+ * Standard Includes
+ */
+
+/*
+ * Project Includes
+ */
+
+#include "common.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Global Variables
+ */
+
+/*
+ * Forward Declarations
+ */
+
+/*
+ * Functions
+ */
+
+extern "C" {
+/*
+ * Calculate the number of elements in the dense storage structure, based on
+ * shape and dim.
+ */
+size_t nm_storage_count_max_elements(const STORAGE* storage) {
+  unsigned int i;
+  size_t count = 1;
+  
+  for (i = storage->dim; i-- > 0;) {
+		count *= storage->shape[i];
+  }
+  
+  return count;
+}
+
+} // end of extern "C" block

data/ext/nmatrix/storage/common.h

@@ -0,0 +1,170 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == common.h
+//
+// Header file for code common to all storage types.
+
+#ifndef STORAGE_COMMON_H
+#define STORAGE_COMMON_H
+
+/*
+ * Standard Includes
+ */
+
+/*
+ * 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);
+
+} // 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 LDType ew_op_switch(LDType left, RDType right) {
+    switch (op) {
+      case EW_ADD:
+        return left + right;
+
+      case EW_SUB:
+        return left - right;
+
+      case EW_MUL:
+        return left * right;
+
+      case EW_DIV:
+        return left / right;
+
+      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 0;
+  }
+
+  #define EWOP_INT_INT_DIV(ltype, rtype)       template <>       \
+  inline ltype 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 ltype 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 ltype 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 ltype 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 ltype 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