nmatrix 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e74b234f446ff409c7d37952bed15df165907f4d
-  data.tar.gz: 5f7f575774e923ac5ec7bd7c86147dbd12130d08
+  metadata.gz: 862e6785562317ff3ffe71dfa679ab58d3bfd219
+  data.tar.gz: 428075f3287f76f862bda8dbf6efa837272e6db9
 SHA512:
-  metadata.gz: 81f4bbbc2365d9bf2df8ce924f525599292b2d9177dc5300193c2628c308d8ae9451f7c29a105e0abf4dca7c6b77473e36947132ea4fa39e1eda968fe06fda40
-  data.tar.gz: e8f9fe883b3c04cd329a081eb2af9d6d9643729be4bc1ee398ec1c5e53dd7b5e77cd7e6acdfd42b93148a4a1353931e2eda880fe81a7656457e0fe7cf7da6f15
+  metadata.gz: 3d845e422a71670756115bb9a9c6eb6c448b89c08f471395a4ffec74b71bdb4052732df7e619aabc1f5a825b5e2c8f36cc215aaa4b1b20192c1575729a5698e2
+  data.tar.gz: 8737125b9d9778afa68ee7ac195014f286d29bea4fc7d33081a14610995e6df312fd2767a56207352534b718ae1c361a4c9ff2a5ad289043c091e4687be0fec9

data/ext/nmatrix/data/complex.h

@@ -32,6 +32,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <type_traits>
 #include <iostream>
 #include <cmath>
@@ -67,23 +68,39 @@ typedef Complex<float64_t> Complex128;
 
 template <typename Type>
 class Complex {
-	public:
-	// The real and immaginary parts of the complex number.
-	Type r;
-	Type i;
+  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) {}
+  /*
+   * Default constructor.
+   */
+  inline Complex(Type real = 0, Type imaginary = 0) : r(real), i(imaginary) {}
+
+  /*
+   * Copy constructors.
+   */
+  template <typename ComplexType>
+  explicit inline Complex(const Complex<ComplexType>& other) : r(other.r), i(other.i) {}
 
-	/*
-	 * Copy constructors.
-	 */
-	template <typename ComplexType>
-	inline Complex(const Complex<ComplexType>& other) : r(other.r), i(other.i) {}
+  template <typename ComplexType>
+  inline Complex<Type>& operator=(const Complex<ComplexType>& other) {
+    this->r = static_cast<Type>(other.r);
+    this->i = static_cast<Type>(other.i);
+    return *this;
+  }
+
+  explicit Complex(const RubyObject& other);
 
-  Complex(const RubyObject& other);
+  Complex<Type>& operator=(const RubyObject& other);
+
+  template<typename OtherType>
+  inline Complex<Type>& operator=(const OtherType& real) {
+    this->r = Type(real);
+    this->i = Type(0);
+    return *this;
+  }
 
   /*
    * Complex conjugate function -- creates a copy, but inverted.
@@ -103,20 +120,25 @@ class Complex {
     return Complex<Type>(conj.r / denom, conj.i / denom);
   }
 
+  // Negative operator
+  inline Complex<Type> operator-() const {
+    return Complex<Type>(-this->r, -this->i);
+  }
 
 
-	/*
-	 * Binary operator definitions for various types.
-	 */
 
-	////////////////////////////////
-	// Complex-Complex Operations //
-	////////////////////////////////
+  /*
+   * Binary operator definitions for various types.
+   */
 
-	template <typename OtherType>
-	inline Complex<Type> operator+(const Complex<OtherType>& other) const {
-		return Complex<Type>(this->r + other.r, this->i + other.i);
-	}
+  ////////////////////////////////
+  // 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) {
@@ -132,15 +154,15 @@ class Complex {
     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);
+  }
 
-	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) 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) {
@@ -149,123 +171,125 @@ class Complex {
     return *this;
   }
 
-	template <typename OtherType>
-	inline Complex<Type> operator/(const Complex<OtherType>& other) const {
-		Type new_r, new_i;
-		Type denom = other.i * other.i + other.r * other.r;
-
-		new_r = (this->r * other.r + this->i * other.i) / denom;
-		new_i = (this->i * other.r - this->r * other.i) / denom;
-
-		return Complex<Type>(new_r, new_i);
-	}
-
-	template <typename OtherType>
-	inline Complex<Type> operator/=(const Complex<OtherType>& other) {
-		Type new_r, new_i;
-		Type denom = other.i * other.i + other.r * other.r;
-
-		new_r = (this->r * other.r + this->i * other.i) / denom;
-		new_i = (this->i * other.r - this->r * other.i) / denom;
-
-		this->r = new_r;
-		this->i = new_i;
-		return *this;
-	}
-
-	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-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;
-	}
+  template <typename OtherType>
+  inline Complex<Type> operator/(const Complex<OtherType>& other) const {
+    Type new_r, new_i;
+    Type denom = other.i * other.i + other.r * other.r;
+
+    new_r = (this->r * other.r + this->i * other.i) / denom;
+    new_i = (this->i * other.r - this->r * other.i) / denom;
+
+    return Complex<Type>(new_r, new_i);
+  }
+
+  template <typename OtherType>
+  inline Complex<Type> operator/=(const Complex<OtherType>& other) {
+    Type new_r, new_i;
+    Type denom = other.i * other.i + other.r * other.r;
+
+    new_r = (this->r * other.r + this->i * other.i) / denom;
+    new_i = (this->i * other.r - this->r * other.i) / denom;
+
+    this->r = new_r;
+    this->i = new_i;
+    return *this;
+  }
+
+  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-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;
+  }
+
+  operator RubyObject () const;
 };
 
 ///////////////////////////////
@@ -274,52 +298,52 @@ class Complex {
 
 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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  return Complex<ComplexType>(left) >= right;
 }
 
 template <typename Type>

data/ext/nmatrix/data/data.cpp

@@ -91,35 +91,82 @@ namespace nm {
     "negate", "floor", "ceil", "round"
   };
 
+
+  /*
+   * 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, nm::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));
+
+      default:
+        try {
+          throw std::logic_error("Cannot create ruby object");
+        }
+        catch (std::logic_error err) {
+          printf("%s\n", err.what());
+        }
+
+        rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown/invalid data type (did you try to convert from a VALUE?)");
+    }
+    return Qnil;
+  }
 } // end of namespace nm
 
 extern "C" {
 
 const char* const DTYPE_NAMES[nm::NUM_DTYPES] = {
-	"byte",
-	"int8",
-	"int16",
-	"int32",
-	"int64",
-	"float32",
-	"float64",
-	"complex64",
-	"complex128",
-	"object"
+  "byte",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "float32",
+  "float64",
+  "complex64",
+  "complex128",
+  "object"
 };
 
 
 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::RubyObject)
+  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::RubyObject)
 };
 
 
@@ -150,100 +197,54 @@ const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
  */
 void rubyval_to_cval(VALUE val, nm::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<Complex128>();
-			break;
-
-		case RUBYOBJ:
-		  *reinterpret_cast<VALUE*>(loc)        = val;
-			//rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
-			break;
-
-	  default:
-	    rb_raise(rb_eTypeError, "Attempting a bad conversion.");
-	    break;
-	}
+  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<Complex128>();
+      break;
+
+    case RUBYOBJ:
+      *reinterpret_cast<VALUE*>(loc)        = val;
+      //rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
+      break;
+
+    default:
+      rb_raise(rb_eTypeError, "Attempting a bad conversion.");
+      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, nm::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));
-			
-	  default:
-	  	try {
-	  		throw std::logic_error("Cannot create ruby object");
-	  	}
-	  	catch (std::logic_error err) {
-	  		printf("%s\n", err.what());
-	  	}
-
-	    rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown/invalid data type (did you try to convert from a VALUE?)");
-	}
-	return Qnil;
-}