nmatrix 0.2.0 → 0.2.1

data/ext/nmatrix/data/ruby_object.h

@@ -47,8 +47,8 @@
  */
 #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.");
+  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
@@ -59,45 +59,45 @@ 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 {};
+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)) {}
+  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.
@@ -120,178 +120,178 @@ class RubyObject {
   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) {}
+   * 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) {
+  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) const {
+    return RubyObject(rb_funcall(this->rval, nm_rb_sub, 1, other.rval));
+  }
 
-	inline RubyObject& operator-=(const RubyObject& other) {
+  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) const {
+    return RubyObject(rb_funcall(this->rval, nm_rb_mul, 1, other.rval));
+  }
 
-	inline RubyObject& operator*=(const RubyObject& other) {
+  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) const {
+    return RubyObject(rb_funcall(this->rval, nm_rb_div, 1, other.rval));
+  }
 
-	inline RubyObject& operator/=(const RubyObject& other) {
+  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 //
-	////////////////////////////
+  }
+  
+  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);
+  }
 
   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);
-	}
+  inline bool operator!=(const NativeType& other) const {
+    return *this != RubyObject(other);
+  }
 */
-	//////////////////////////////
-	// RUBY-COMPLEX OPERATIONS //
-	//////////////////////////////
+  //////////////////////////////
+  // 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);
+  }
 
   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.");
-		}
-	}
+  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));
@@ -344,32 +344,32 @@ inline bool operator>(const NativeType left, const RubyObject& 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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  return RubyObject(left) > right;
 }
 
 } // end of namespace nm