nmatrix 0.0.1 → 0.0.2

data/ext/nmatrix/data/complex.h

@@ -0,0 +1,372 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == complex.h
+//
+// Functions and classes for dealing with complex numbers.
+
+#ifndef COMPLEX_H
+#define COMPLEX_H
+
+/*
+ * Standard Includes
+ */
+
+#include <type_traits>
+#include <iostream>
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+namespace nm {
+
+template <typename IntType> class Rational;
+template <typename Type> class Complex;
+
+typedef Complex<float32_t> Complex64;
+typedef Complex<float64_t> Complex128;
+
+/*
+ * Data
+ */
+ 
+/*
+ * Classes and Functions
+ */
+
+template <typename Type>
+class Complex {
+	public:
+	// The real and immaginary parts of the complex number.
+	Type r;
+	Type i;
+	
+	/*
+	 * Default constructor.
+	 */
+	inline Complex(Type real = 0, Type imaginary = 0) : r(real), i(imaginary) {}
+	
+	/*
+	 * Copy constructors.
+	 */
+	template <typename ComplexType>
+	inline Complex(const Complex<ComplexType>& other) : r(other.r), i(other.i) {}
+
+	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+	inline Complex(const Rational<IntType>& other) : r(Type(other.n) / Type(other.d)), i(0) {}
+
+  /*
+   * Complex conjugate function -- creates a copy, but inverted.
+   */
+  inline Complex<Type> conjugate() const {
+    return Complex<Type>(this->r, -(this->i));
+  }
+
+  /*
+   * Complex inverse function -- creates a copy, but inverted.
+   *
+   * FIXME: Check that this doesn't duplicate functionality of NativeType / Complex<Type>
+   */
+  inline Complex<Type> inverse() const {
+    Complex<Type> conj = conjugate();
+    Type denom = this->r * this->r + this->i * this->i;
+    return Complex<Type>(conj.r / denom, conj.i / denom);
+  }
+
+
+
+	/*
+	 * Binary operator definitions for various types.
+	 */
+	
+	////////////////////////////////
+	// Complex-Complex Operations //
+	////////////////////////////////
+	
+	template <typename OtherType>
+	inline Complex<Type> operator+(const Complex<OtherType>& other) const {
+		return Complex<Type>(this->r + other.r, this->i + other.i);
+	}
+
+  template <typename OtherType>
+  inline Complex<Type>& operator+=(const Complex<OtherType>& other) {
+    this->r += other.r;
+    this->i += other.i;
+    return *this;
+  }
+
+	template <typename OtherType>
+	inline Complex<Type> operator-(const Complex<OtherType>& other) const {
+		return Complex<Type>(this->r - other.r, this->i - other.i);
+	}
+	
+	template <typename OtherType>
+	inline Complex<Type> operator*(const Complex<OtherType>& other) const {
+		return Complex<Type>(this->r * other.r - this->i * other.i, this->r * other.i - this->i * other.r);
+	}
+
+  template <typename OtherType>
+  inline Complex<Type>& operator*=(const Complex<OtherType>& other) {
+    this->r = this->r * other.r - this->i * other.i;
+    this->i = this->r * other.i - this->i * other.r;
+    return *this;
+  }
+
+	template <typename OtherType>
+	inline Complex<Type> operator/(const Complex<OtherType>& other) const {
+		Type new_r, new_i;
+		Type denom = this->i * this->i + other.r * other.r;
+		
+		new_r = (this->r * other.r + this->i * other.i) / denom;
+		new_i = (this->r * other.i - this->i * other.r) / denom;
+		
+		return Complex<Type>(new_r, new_i);
+	}
+	
+	template <typename OtherType>
+	inline bool operator<(const Complex<OtherType>& other) const {
+		return (this->r < other.r) || ((this->r <= other.r) && (this->i < other.i));
+	}
+	
+	template <typename OtherType>
+	inline bool operator>(const Complex<OtherType>& other) const {
+		return (this->r > other.r) || ((this->r >= other.r) && (this->i > other.i));
+	}
+	
+	template <typename OtherType>
+	inline bool operator==(const Complex<OtherType>& other) const {
+		return FP_EQUAL(this->r, other.r) && FP_EQUAL(this->i, other.i);
+	}
+	
+	template <typename OtherType>
+	inline bool operator!=(const Complex<OtherType>& other) const {
+		return !(*this == other);
+	}
+	
+	template <typename OtherType>
+	inline bool operator<=(const Complex<OtherType>& other) const {
+		return (*this < other) || (*this == other);
+	}
+	
+	template <typename OtherType>
+	inline bool operator>=(const Complex<OtherType>& other) const {
+		return (*this > other) || (*this == other);
+	}
+	
+	template <typename OtherType>
+	inline operator Complex<OtherType> () const {
+		return Complex<OtherType>((OtherType)this->r, (OtherType)this->i);
+	}
+
+	/////////////////////////////////
+	// Complex-Rational Operations //
+	/////////////////////////////////
+	
+	template <typename RationalType>
+	inline Complex<Type> operator+(const Rational<RationalType>& other) const {
+		return *this + Complex<Type>(other);
+	}
+	
+	template <typename RationalType>
+	inline Complex<Type> operator-(const Rational<RationalType>& other) const {
+		return *this * Complex<Type>(other);
+	}
+	
+	template <typename RationalType>
+	inline Complex<Type> operator*(const Rational<RationalType>& other) const {
+		return *this * Complex<Type>(other);
+	}
+	
+	template <typename RationalType>
+	inline Complex<Type> operator/(const Rational<RationalType>& other) const {
+		return *this / Complex<Type>(other);
+	}
+	
+	template <typename RationalType, typename = typename std::enable_if<std::is_integral<RationalType>::value>::type>
+	inline bool operator!=(const Rational<RationalType>& other) const {
+	  return *this != Complex<Type>(other);
+	}
+
+  template <typename RationalType, typename = typename std::enable_if<std::is_integral<RationalType>::value>::type>
+	inline bool operator==(const Rational<RationalType>& other) const {
+	  return *this == Complex<Type>(other);
+	}
+
+	///////////////////////////////
+	// Complex-Native Operations //
+	///////////////////////////////
+	
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline Complex<Type> operator+(const NativeType& other) const {
+		return *this + Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline Complex<Type> operator-(const NativeType& other) const {
+		return *this - Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline Complex<Type> operator*(const NativeType& other) const {
+		return *this * Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline Complex<Type> operator/(const NativeType& other) const {
+		return *this / Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator<(const NativeType& other) const {
+		return *this < Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator>(const NativeType& other) const {
+		return *this > Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator==(const NativeType& other) const {
+		return *this == Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator!=(const NativeType& other) const {
+		return *this != Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator<=(const NativeType& other) const {
+		return *this <= Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline bool operator>=(const NativeType& other) const {
+		return *this >= Complex<Type>(other);
+	}
+
+	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+	inline operator NativeType () const {
+		return (NativeType)this->r;
+	}
+};
+
+
+/////////////////////////////////
+// Rational-Complex Operations //
+/////////////////////////////////
+
+
+template <typename IntType, typename ComplexType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator==(const Rational<IntType>& left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) == right;
+}
+
+template <typename IntType, typename ComplexType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator!=(const Rational<IntType>& left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) != right;
+}
+
+
+///////////////////////////////
+// Native-Complex Operations //
+///////////////////////////////
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline Complex<ComplexType> operator+(const NativeType& left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) + right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline Complex<ComplexType> operator-(const NativeType& left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) - right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline Complex<ComplexType> operator*(const NativeType& left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) * right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline Complex<ComplexType> operator/(const NativeType& left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) / right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator<(const NativeType left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) < right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator>(const NativeType left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) > right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator==(const NativeType left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) == right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator!=(const NativeType left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) != right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator<=(const NativeType left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) <= right;
+}
+
+template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator>=(const NativeType left, const Complex<ComplexType>& right) {
+	return Complex<ComplexType>(left) >= right;
+}
+
+template <typename Type>
+inline std::ostream& operator<<(std::ostream& out, const Complex<Type>& rhs) {
+  out << "(" << rhs.r << "," << rhs.i << "i)" << std::flush;
+  return out;
+}
+
+} // end of namespace nm
+
+namespace std {
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  nm::Complex<FloatType> abs(const nm::Complex<FloatType>& value) {
+    return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
+                                  value.i < 0 ? -value.i : value.i);
+  }
+}
+
+#endif // COMPLEX_H

data/ext/nmatrix/data/data.cpp

@@ -0,0 +1,275 @@
+/////////////////////////////////////////////////////////////////////
+// = 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.cpp
+//
+// Functions and data for dealing the data types.
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+#include "data.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Global Variables
+ */
+
+extern "C" {
+
+const char* const DTYPE_NAMES[nm::NUM_DTYPES] = {
+	"byte",
+	"int8",
+	"int16",
+	"int32",
+	"int64",
+	"float32",
+	"float64",
+	"complex64",
+	"complex128",
+	"rational32",
+	"rational64",
+	"rational128",
+	"object"
+};
+
+const char* const ITYPE_NAMES[nm::NUM_ITYPES] = {
+	"uint8",
+	"uint16",
+	"uint32",
+	"uint64"
+};
+
+const size_t DTYPE_SIZES[nm::NUM_DTYPES] = {
+	sizeof(uint8_t),
+	sizeof(int8_t),
+	sizeof(int16_t),
+	sizeof(int32_t),
+	sizeof(int64_t),
+	sizeof(float32_t),
+	sizeof(float64_t),
+	sizeof(nm::Complex64),
+	sizeof(nm::Complex128),
+	sizeof(nm::Rational32),
+	sizeof(nm::Rational64),
+	sizeof(nm::Rational128),
+	sizeof(nm::RubyObject)
+};
+
+const size_t ITYPE_SIZES[nm::NUM_ITYPES] = {
+	sizeof(uint8_t),
+	sizeof(uint16_t),
+	sizeof(uint32_t),
+	sizeof(uint64_t),
+};
+
+const dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
+  { BYTE, INT8, INT16, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { INT8, INT8, INT16, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { INT16, INT16, INT16, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { INT32, INT32, INT32, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { INT64, INT64, INT64, INT64, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { FLOAT32, FLOAT32, FLOAT32, FLOAT32, FLOAT32, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, FLOAT64, FLOAT64, FLOAT64, RUBYOBJ},
+  { FLOAT64, FLOAT64, FLOAT64, FLOAT64, FLOAT64, FLOAT64, FLOAT64, COMPLEX128, COMPLEX128, FLOAT64, FLOAT64, FLOAT64, RUBYOBJ},
+  { COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX128, COMPLEX64, COMPLEX128, COMPLEX64, COMPLEX64, COMPLEX64, RUBYOBJ},
+  { COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, RUBYOBJ},
+  { RATIONAL32, RATIONAL32, RATIONAL32, RATIONAL32, RATIONAL32, FLOAT64, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { RATIONAL64, RATIONAL64, RATIONAL64, RATIONAL64, RATIONAL64, FLOAT64, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL64, RATIONAL64, RATIONAL128, RUBYOBJ},
+  { RATIONAL128, RATIONAL128, RATIONAL128, RATIONAL128, RATIONAL128, FLOAT64, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL128, RATIONAL128, RATIONAL128, RUBYOBJ},
+  { RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ}
+};
+
+
+/*
+ * Forward Declarations
+ */
+
+/*
+ * Functions
+ */
+
+/*
+ * Converts a RubyObject
+ */
+void rubyval_to_cval(VALUE val, dtype_t dtype, void* loc) {
+  using namespace nm;
+	switch (dtype) {
+		case BYTE:
+			*reinterpret_cast<uint8_t*>(loc)			= static_cast<uint8_t>(RubyObject(val));
+			break;
+
+		case INT8:
+			*reinterpret_cast<int8_t*>(loc)				= static_cast<int8_t>(RubyObject(val));
+			break;
+
+		case INT16:
+			*reinterpret_cast<int16_t*>(loc)			= static_cast<int16_t>(RubyObject(val));
+			break;
+
+		case INT32:
+			*reinterpret_cast<int32_t*>(loc)			= static_cast<int32_t>(RubyObject(val));
+			break;
+
+		case INT64:
+			*reinterpret_cast<int64_t*>(loc)			= static_cast<int64_t>(RubyObject(val));
+			break;
+
+		case FLOAT32:
+			*reinterpret_cast<float32_t*>(loc)		= static_cast<float32_t>(RubyObject(val));
+			break;
+
+		case FLOAT64:
+			*reinterpret_cast<float64_t*>(loc)		= static_cast<float64_t>(RubyObject(val));
+			break;
+
+		case COMPLEX64:
+			*reinterpret_cast<Complex64*>(loc)		= RubyObject(val).to<Complex64>();
+			break;
+
+		case COMPLEX128:
+			*reinterpret_cast<Complex128*>(loc)		= RubyObject(val).to<Complex64>();
+			break;
+
+		case RATIONAL32:
+			*reinterpret_cast<Rational32*>(loc)		= RubyObject(val).to<Rational32>();
+			break;
+
+		case RATIONAL64:
+			*reinterpret_cast<Rational64*>(loc)		= RubyObject(val).to<Rational64>();
+			break;
+
+		case RATIONAL128:
+			*reinterpret_cast<Rational128*>(loc)	= RubyObject(val).to<Rational128>();
+			break;
+
+		case RUBYOBJ:
+		  *reinterpret_cast<VALUE*>(loc)        = RubyObject(val).rval;
+			//rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
+			break;
+
+	  default:
+	    rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
+	    break;
+	}
+}
+
+/*
+ * Create a RubyObject from a regular C value (given a dtype). Does not return a VALUE! To get a VALUE, you need to
+ * look at the rval property of what this function returns.
+ */
+nm::RubyObject rubyobj_from_cval(void* val, dtype_t dtype) {
+  using namespace nm;
+	switch (dtype) {
+		case BYTE:
+			return RubyObject(*reinterpret_cast<uint8_t*>(val));
+
+		case INT8:
+			return RubyObject(*reinterpret_cast<int8_t*>(val));
+
+		case INT16:
+			return RubyObject(*reinterpret_cast<int16_t*>(val));
+
+		case INT32:
+			return RubyObject(*reinterpret_cast<int32_t*>(val));
+
+		case INT64:
+			return RubyObject(*reinterpret_cast<int64_t*>(val));
+
+		case FLOAT32:
+			return RubyObject(*reinterpret_cast<float32_t*>(val));
+
+		case FLOAT64:
+			return RubyObject(*reinterpret_cast<float64_t*>(val));
+
+		case COMPLEX64:
+			return RubyObject(*reinterpret_cast<Complex64*>(val));
+
+		case COMPLEX128:
+			return RubyObject(*reinterpret_cast<Complex128*>(val));
+			
+		case RATIONAL32:
+			return RubyObject(*reinterpret_cast<Rational32*>(val));
+			
+		case RATIONAL64:
+			return RubyObject(*reinterpret_cast<Rational64*>(val));
+			
+		case RATIONAL128:
+			return RubyObject(*reinterpret_cast<Rational128*>(val));
+
+	  default:
+	    rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown/invalid data type (did you try to convert from a VALUE?)");
+	}
+	return Qnil;
+}
+
+
+/*
+ * Convert from itype instead of dtype
+ */
+nm::RubyObject rubyobj_from_cval_by_itype(void* val, itype_t itype) {
+  using namespace nm;
+	switch (itype) {
+		case UINT8:
+			return RubyObject(*reinterpret_cast<uint8_t*>(val));
+
+		case UINT16:
+			return RubyObject((int16_t)(*reinterpret_cast<uint16_t*>(val)));
+
+		case UINT32:
+			return RubyObject((int32_t)(*reinterpret_cast<uint32_t*>(val)));
+
+		case UINT64:
+			return RubyObject((int64_t)(*reinterpret_cast<uint64_t*>(val)));
+
+	  default:
+	    rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown data type");
+	}
+	return Qnil;
+}
+
+/*
+ * Allocate and return a piece of data of the correct dtype, converted from a
+ * given RubyObject.
+ */
+void* rubyobj_to_cval(VALUE val, dtype_t dtype) {
+  size_t size =  DTYPE_SIZES[dtype];
+  void* ret_val = ALLOC_N(char, size);
+
+  rubyval_to_cval(val, dtype, ret_val);
+
+  return ret_val;
+}
+
+} // end of extern "C" block