nmatrix-lapacke 0.2.0

data/ext/nmatrix/data/meta.h

@@ -0,0 +1,64 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == meta.h
+//
+// Header file for dealing with template metaprogramming.
+
+#ifndef META_H
+# define META_H
+
+namespace nm {
+  /*
+   * Template Metaprogramming
+   */
+  template <typename T> struct ctype_to_dtype_enum {
+    static const nm::dtype_t value_type = nm::BYTE;
+  };
+  template <> struct ctype_to_dtype_enum<uint8_t> { static const nm::dtype_t value_type = nm::BYTE; };
+  template <> struct ctype_to_dtype_enum<int8_t>  { static const nm::dtype_t value_type = nm::INT8; };
+  template <> struct ctype_to_dtype_enum<int16_t> { static const nm::dtype_t value_type = nm::INT16; };
+  template <> struct ctype_to_dtype_enum<int32_t> { static const nm::dtype_t value_type = nm::INT32; };
+  template <> struct ctype_to_dtype_enum<int64_t> { static const nm::dtype_t value_type = nm::INT64; };
+  template <> struct ctype_to_dtype_enum<float>   { static const nm::dtype_t value_type = nm::FLOAT32; };
+  template <> struct ctype_to_dtype_enum<double>  { static const nm::dtype_t value_type = nm::FLOAT64; };
+  template <> struct ctype_to_dtype_enum<Complex64>   { static const nm::dtype_t value_type = nm::COMPLEX64; };
+  template <> struct ctype_to_dtype_enum<Complex128>  { static const nm::dtype_t value_type = nm::COMPLEX128; };
+  template <> struct ctype_to_dtype_enum<RubyObject>  { static const nm::dtype_t value_type = nm::RUBYOBJ; };
+
+
+  template <nm::dtype_t Enum> struct dtype_enum_T;
+  template <> struct dtype_enum_T<nm::BYTE> { typedef uint8_t type; };
+  template <> struct dtype_enum_T<nm::INT8>  { typedef int8_t type;  };
+  template <> struct dtype_enum_T<nm::INT16> { typedef int16_t type; };
+  template <> struct dtype_enum_T<nm::INT32> { typedef int32_t type; };
+  template <> struct dtype_enum_T<nm::INT64> { typedef int64_t type; };
+  template <> struct dtype_enum_T<nm::FLOAT32> { typedef float type; };
+  template <> struct dtype_enum_T<nm::FLOAT64> { typedef double type; };
+  template <> struct dtype_enum_T<nm::COMPLEX64> { typedef nm::Complex64 type; };
+  template <> struct dtype_enum_T<nm::COMPLEX128> { typedef nm::Complex128 type; };
+  template <> struct dtype_enum_T<nm::RUBYOBJ> { typedef nm::RubyObject type; };
+
+} // end namespace nm
+
+#endif

data/ext/nmatrix/data/ruby_object.h

@@ -0,0 +1,389 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == ruby_object.h
+//
+// Functions and classes for dealing with Ruby objects.
+
+#ifndef RUBY_OBJECT_H
+#define RUBY_OBJECT_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <iostream>
+#include <type_traits>
+
+/*
+ * Project Includes
+ */
+
+#include "ruby_constants.h"
+
+/*
+ * Macros
+ */
+#define NM_RUBYVAL_IS_NUMERIC(val)                (FIXNUM_P(val) or (TYPE(val) == T_FLOAT) or (TYPE(val) == T_COMPLEX))
+#define NMATRIX_CHECK_TYPE(val) \
+	if (TYPE(val) != T_DATA || (RDATA(val)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(val)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) \
+		rb_raise(rb_eTypeError, "Expected NMatrix on left-hand side of operation.");
+
+/*
+ * Classes and Functions
+ */
+
+namespace nm {
+template<typename T, typename U>
+struct made_from_same_template : std::false_type {}; 
+ 
+template<template<typename> class Templ, typename Arg1, typename Arg2>
+struct made_from_same_template<Templ<Arg1>, Templ<Arg2>> : std::true_type {};
+
+class RubyObject {
+	public:
+	VALUE rval;
+	
+	/*
+	 * Value constructor.
+	 */
+	inline RubyObject(VALUE ref = Qnil) : rval(ref) {}
+	
+	/*
+	 * Complex number constructor.
+	 */
+	template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+	inline RubyObject(const Complex<FloatType>& other) : rval(rb_complex_new(rb_float_new(other.r), rb_float_new(other.i))) {}
+	
+	/*
+	 * Integer constructor.
+	 *
+	 * Does not work as a template.
+	 */
+	inline RubyObject(uint8_t other)  : rval(INT2FIX(other)) {}
+	inline RubyObject(int8_t other)   : rval(INT2FIX(other)) {}
+	inline RubyObject(int16_t other)  : rval(INT2FIX(other)) {}
+	inline RubyObject(uint16_t other) : rval(INT2FIX(other)) {}
+	inline RubyObject(int32_t other)  : rval(INT2FIX(other)) {}
+	// there is no uint32_t here because that's a Ruby VALUE type, and we need the compiler to treat that as a VALUE.
+	inline RubyObject(int64_t other)  : rval(INT2FIX(other)) {}
+//	inline RubyObject(uint64_t other) : rval(INT2FIX(other)) {}
+
+
+	/*
+	 * Float constructor.
+	 *
+	 * Does not work as a template.
+	 */
+	inline RubyObject(float other)   : rval(rb_float_new(other)) {}
+	inline RubyObject(double other)  : rval(rb_float_new(other)) {}
+
+  /*
+   * Operators for converting RubyObjects to other C types.
+   */
+
+#define RETURN_OBJ2NUM(mac)   if (this->rval == Qtrue) return 1; else if (this->rval == Qfalse) return 0; else return mac(this->rval);
+
+  inline operator int8_t()  const { RETURN_OBJ2NUM(NUM2INT)         }
+  inline operator uint8_t() const { RETURN_OBJ2NUM(NUM2UINT)        }
+  inline operator int16_t() const { RETURN_OBJ2NUM(NUM2INT)         }
+  inline operator uint16_t() const { RETURN_OBJ2NUM(NUM2UINT)       }
+  inline operator int32_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
+  inline operator VALUE() const { return rval; }
+  //inline operator uint32_t() const { return NUM2ULONG(this->rval);      }
+  inline operator int64_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
+  inline operator uint64_t() const { RETURN_OBJ2NUM(NUM2ULONG)      }
+  inline operator double()   const { RETURN_OBJ2NUM(NUM2DBL)        }
+  inline operator float()  const { RETURN_OBJ2NUM(NUM2DBL)          }
+
+  inline operator Complex64() const { return this->to<Complex64>(); }
+  inline operator Complex128() const { return this->to<Complex128>(); }
+  /*
+	 * Copy constructors.
+	 */
+	inline RubyObject(const RubyObject& other) : rval(other.rval) {}
+
+  /*
+   * Inverse operator.
+   */
+	inline RubyObject inverse() const {
+	  rb_raise(rb_eNotImpError, "RubyObject#inverse needs to be implemented");
+	}
+
+	/*
+	 * Absolute value.
+	 */
+	inline RubyObject abs() const {
+	  return RubyObject(rb_funcall(this->rval, rb_intern("abs"), 0));
+	}
+
+	/*
+	 * Binary operator definitions.
+	 */
+	
+	inline RubyObject operator+(const RubyObject& other) const {
+		return RubyObject(rb_funcall(this->rval, nm_rb_add, 1, other.rval));
+	}
+
+	inline RubyObject& operator+=(const RubyObject& other) {
+    this->rval = rb_funcall(this->rval, nm_rb_add, 1, other.rval);
+    return *this;
+	}
+
+	inline RubyObject operator-(const RubyObject& other) const {
+		return RubyObject(rb_funcall(this->rval, nm_rb_sub, 1, other.rval));
+	}
+
+	inline RubyObject& operator-=(const RubyObject& other) {
+    this->rval = rb_funcall(this->rval, nm_rb_sub, 1, other.rval);
+    return *this;
+	}
+	
+	inline RubyObject operator*(const RubyObject& other) const {
+		return RubyObject(rb_funcall(this->rval, nm_rb_mul, 1, other.rval));
+	}
+
+	inline RubyObject& operator*=(const RubyObject& other) {
+    this->rval = rb_funcall(this->rval, nm_rb_mul, 1, other.rval);
+    return *this;
+	}
+	
+	inline RubyObject operator/(const RubyObject& other) const {
+		return RubyObject(rb_funcall(this->rval, nm_rb_div, 1, other.rval));
+	}
+
+	inline RubyObject& operator/=(const RubyObject& other) {
+    this->rval = rb_funcall(this->rval, nm_rb_div, 1, other.rval);
+    return *this;
+	}
+	
+	inline RubyObject operator%(const RubyObject& other) const {
+		return RubyObject(rb_funcall(this->rval, nm_rb_percent, 1, other.rval));
+	}
+	
+	inline bool operator>(const RubyObject& other) const {
+		return rb_funcall(this->rval, nm_rb_gt, 1, other.rval) == Qtrue;
+	}
+	
+	inline bool operator<(const RubyObject& other) const {
+		return rb_funcall(this->rval, nm_rb_lt, 1, other.rval) == Qtrue;
+	}
+
+	template <typename OtherType>
+	inline bool operator<(const OtherType& other) const {
+		return *this < RubyObject(other);
+	}
+	
+	inline bool operator==(const RubyObject& other) const {
+		return rb_funcall(this->rval, nm_rb_eql, 1, other.rval) == Qtrue;
+	}
+
+	template <typename OtherType>
+	inline bool operator==(const OtherType& other) const {
+		return *this == RubyObject(other);
+	}
+	
+	inline bool operator!=(const RubyObject& other) const {
+		return rb_funcall(this->rval, nm_rb_neql, 1, other.rval) == Qtrue;
+	}
+
+	template <typename OtherType>
+	inline bool operator!=(const OtherType& other) const {
+		return *this != RubyObject(other);
+	}
+	
+	inline bool operator>=(const RubyObject& other) const {
+		return rb_funcall(this->rval, nm_rb_gte, 1, other.rval) == Qtrue;
+	}
+
+	template <typename OtherType>
+	inline bool operator>=(const OtherType& other) const {
+		return *this >= RubyObject(other);
+	}
+	
+	inline bool operator<=(const RubyObject& other) const {
+		return rb_funcall(this->rval, nm_rb_lte, 1, other.rval) == Qtrue;
+	}
+
+	template <typename OtherType>
+	inline bool operator<=(const OtherType& other) const {
+		return *this <= RubyObject(other);
+	}
+
+	////////////////////////////
+	// RUBY-NATIVE OPERATIONS //
+	////////////////////////////
+/*
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator==(const NativeType& other) const {
+		return *this == RubyObject(other);
+	}
+
+  template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator!=(const NativeType& other) const {
+		return *this != RubyObject(other);
+	}
+*/
+	//////////////////////////////
+	// RUBY-COMPLEX OPERATIONS //
+	//////////////////////////////
+
+	template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+	inline bool operator==(const Complex<FloatType>& other) const {
+		return *this == RubyObject(other);
+	}
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+	inline bool operator!=(const Complex<FloatType>& other) const {
+		return *this != RubyObject(other);
+	}
+
+	/*
+	 * Convert a Ruby object to an integer.
+	 */
+	template <typename IntType>
+	inline typename std::enable_if<std::is_integral<IntType>::value, IntType>::type to(void) {
+		return NUM2INT(this->rval);
+	}
+	
+	/*
+	 * Convert a Ruby object to a floating point number.
+	 */
+	template <typename FloatType>
+	inline typename std::enable_if<std::is_floating_point<FloatType>::value, FloatType>::type to(void) {
+		return NUM2DBL(this->rval);
+	}
+	
+	/*
+	 * Convert a Ruby object to a complex number.
+	 */
+	template <typename ComplexType>
+	inline typename std::enable_if<made_from_same_template<ComplexType, Complex64>::value, ComplexType>::type to(void) const {
+		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT) {
+			return ComplexType(NUM2DBL(this->rval));
+			
+		} else if (TYPE(this->rval) == T_COMPLEX) {
+			return ComplexType(NUM2DBL(rb_funcall(this->rval, nm_rb_real, 0)), NUM2DBL(rb_funcall(this->rval, nm_rb_imag, 0)));
+			
+		} else {
+			rb_raise(rb_eTypeError, "Invalid conversion to Complex type.");
+		}
+	}
+};
+	
+// Negative operator
+inline RubyObject operator-(const RubyObject& rhs) {
+  return RubyObject(rb_funcall(rhs.rval, nm_rb_negate, 0));
+}
+
+
+////////////////////////////
+// NATIVE-RUBY OPERATIONS //
+////////////////////////////
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline RubyObject operator/(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) / right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator==(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) == right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator!=(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) != right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator<=(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) <= right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator>=(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) >= right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator<(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) < right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator>(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) > right;
+}
+
+
+/////////////////////////////
+// COMPLEX-RUBY OPERATIONS //
+/////////////////////////////
+
+template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+inline bool operator==(const Complex<FloatType>& left, const RubyObject& right) {
+	return RubyObject(left) == right;
+}
+
+template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+inline bool operator!=(const Complex<FloatType>& left, const RubyObject& right) {
+	return RubyObject(left) != right;
+}
+
+template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+inline bool operator<=(const Complex<FloatType>& left, const RubyObject& right) {
+	return RubyObject(left) <= right;
+}
+
+template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+inline bool operator>=(const Complex<FloatType>& left, const RubyObject& right) {
+	return RubyObject(left) >= right;
+}
+
+template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+inline bool operator<(const Complex<FloatType>& left, const RubyObject& right) {
+	return RubyObject(left) < right;
+}
+
+template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+inline bool operator>(const Complex<FloatType>& left, const RubyObject& right) {
+	return RubyObject(left) > right;
+}
+
+} // end of namespace nm
+
+namespace std {
+  inline nm::RubyObject abs(const nm::RubyObject& obj) {
+    return obj.abs();
+  }
+
+
+  inline nm::RubyObject sqrt(const nm::RubyObject& obj) {
+    VALUE cMath = rb_const_get(rb_cObject, rb_intern("Math"));
+    return nm::RubyObject(rb_funcall(cMath, rb_intern("sqrt"), 1, obj.rval));
+  }
+}
+
+#endif // RUBY_OBJECT_H