nmatrix 0.1.0.rc5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 101aa626bcac374a9e9d435b01f81ce119df0589
-  data.tar.gz: 003a943f6e7a84371460c36cf7eec4b6e5edc732
+  metadata.gz: 707562a21915c1dd82f64baaf3102ff11c83c1fb
+  data.tar.gz: 695cf665b38511084ff5d9d282583a31566dbaed
 SHA512:
-  metadata.gz: 8caa3986e557c54d6040e86201537dce92c3db161a27d545059244a4e32b7dab2dd396962d1ac77724dffb499d9076aa6c9637dee688149fae7a072e2a03890e
-  data.tar.gz: 20fb3e32a7f7d59a02e20435ea80430ddddd20f6d479862ebc52e2dbc180ed17e0c1d35a3d9e7a7d65675ac0d382bed83b43a5cc3a1e9ea1478fbf66ba60dc52
+  metadata.gz: afd36e03a78d177fab72efcf967f3cf942408f22de02ca3cf85dd23e527e02fc73c7b9946b782bee13ae2312d07f17cc8b3288d342c435f59093ad03a0dc6f27
+  data.tar.gz: f247048abadfa6877951bad30f92534d1172b67b5967b58b325a113fbd77fbcf245db06181723ebeb75e0312b6f8d50d9418c0e0b6f47875d13333ffaae21811

data/.travis.yml

@@ -3,7 +3,6 @@ cache: bundler
 env:
   - CPLUS_INCLUDE_PATH=/usr/include/atlas C_INCLUDE_PATH=/usr/include/atlas
 rvm:
-  - "1.9.2"
   - "1.9.3"
   - "2.0.0"
   - "2.1.0"

data/Gemfile

@@ -1,4 +1,2 @@
 source 'https://rubygems.org'
 gemspec
-
-gem 'packable', ">= 1.3.5"  # for Matlab IO

data/History.txt

@@ -632,11 +632,46 @@
 
   * Fixed Yale #inject behavior (by @yoongkang)
 
-=== 0.1.0.rc6 / 2014-08-??
+=== 0.1.0 / 2014-12-11
 
-* No major enhancements.
+* 3 major enhancements:
+
+  * Updated to BSD 3-clause license
+
+  * Removed Ruby 1.9.2 support; now requires Ruby 1.9.3 or 
+    higher (by @v0dro)
+
+  * Added Gauss-Jordan elimination for calculation of
+    matrix inverses (by @v0dro)
+
+* 6 minor enhancements:
+
+  * Added trace method for square matrices
+
+  * Improved Array#to_nm monkey patch so matrices and
+    arrays can be interconverted easily, without need for a
+    shape argument (by @andrewcsmith)
+
+  * Added Harwell-Boeing and Fortran matrix format parsers
+    (by @v0dro)
+
+  * Removed soon-to-be-deprecated autoloads and replaced
+    with a more robust method (by @duggiefresh)
+
+  * Updated rake install task to use Bundler's GemHelper
+    install task (by @duggiefresh)
+
+  * Moved packable requirement from Gemfile to gemspec
+    (by @andrewcsmith)
+
+* 3 bug fixes:
 
-* No minor enhancements.
+  * Corrected Ubuntu clapack functionality checking, which
+    should fix most functions which rely on the ATLAS
+    version of clapack
 
-* No bug fixes.
+  * Corrected NMatrix::gesdd workspace request size (by
+    @yoongkang)
 
+  * Fixed definition of NMatrix#asum for one-by-one
+    matrices (by @andrewcsmith)

data/LICENSE.txt

@@ -9,7 +9,7 @@ You *must* read the Contributor Agreement before contributing code to the SciRub
 
 -----
 
-Copyright (c) 2010 - 2014, Ruby Science Foundation
+Copyright (c) 2010 - 2015, John Woods and the Ruby Science Foundation
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
@@ -18,4 +18,6 @@ Redistribution and use in source and binary forms, with or without modification,
 
 * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 
+* Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Manifest.txt

@@ -14,6 +14,8 @@ lib/nmatrix/io/market.rb
 lib/nmatrix/io/mat5_reader.rb
 lib/nmatrix/io/mat_reader.rb
 lib/nmatrix/io/point_cloud.rb
+lib/nmatrix/io/fortran_format.rb
+lib/nmatrix/io/harwell_boeing.rb
 lib/nmatrix/blas.rb
 lib/nmatrix/enumerate.rb
 lib/nmatrix/homogeneous.rb

data/README.rdoc

@@ -31,7 +31,7 @@ However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] wi
 
 * ATLAS, preferably with CLAPACK ({see here for details}[https://github.com/SciRuby/nmatrix/wiki/Installation])
 * a version of GCC or clang which supports C++0x or C++11
-* Ruby 1.9.2+
+* Ruby 1.9.3+
 * {packable}[http://github.com/marcandre/packable] 1.3.5 (used for I/O)
 
 If you want to obtain the latest (development) code, you should generally do:
@@ -104,6 +104,7 @@ The following features exist in the current version of NMatrix (0.1.0.rc1):
 * Input/output:
   * Matlab .MAT v5 file input
   * MatrixMarket file input/output
+  * Harwell-Boeing and Fortran file input
   * Point Cloud Library PCD file input
 * C and C++ API
 * BLAS internal implementations (no library) and ATLAS (with library) access:
@@ -122,29 +123,20 @@ The following features exist in the current version of NMatrix (0.1.0.rc1):
   * xGESVD, xGESDD (singular value decomposition)
   * xGEEV (eigenvalue decomposition of a asymmetric square matrices)
 * LU decomposition
-* Matrix inversions (requires LAPACK; BLAS dtypes only)
+* Matrix inversions
 * Determinant calculation for BLAS dtypes
-* Vector 2-norms
+* Traces
 * Ruby/GSL interoperability (requires {SciRuby's fork of rb-gsl}[http://github.com/SciRuby/rb-gsl])
 * slice assignments, e.g.,
     x[1..3,0..4] = some_other_matrix
 
 === Planned Features (Short-to-Medium Term)
 
-We are nearing the release of NMatrix 0.1.0, our first beta.
-
-These are features planned for NMatrix 0.2.0:
-
-* LAPACK-free calculation of determinant, trace, and eigenvalues (characteristic polynomial)
-* LAPACK-free matrix inversions
-* tensor products
-* improved file I/O
-  * compression of yale symmetries in I/O
-* optimization of non-BLAS data types on BLAS-like operations (e.g., matrix multiplication for rational numbers)
+See the issues tracker for a list of planned features or to request new ones.
 
 == License
 
-Copyright (c) 2012--14, John Woods and the Ruby Science Foundation.
+Copyright (c) 2012--15, John Woods and the Ruby Science Foundation.
 
 All rights reserved.
 

data/Rakefile

@@ -207,7 +207,10 @@ end
 require "rdoc/task"
 RDoc::Task.new do |rdoc|
   rdoc.main = "README.rdoc"
-  rdoc.rdoc_files.include(%w{README.rdoc History.txt LICENSE.txt CONTRIBUTING.md ext/nmatrix/binary_format.txt lib/nmatrix/**/*.rb ext/nmatrix/**/*.cpp ext/nmatrix/**/*.c ext/nmatrix/**/*.h})
+  rdoc.rdoc_files.include(%w{README.rdoc History.txt LICENSE.txt CONTRIBUTING.md lib ext})
+  rdoc.options << "--exclude=ext/nmatrix/extconf.rb"
+  rdoc.options << "--exclude=ext/nmatrix/ttable_helper.rb"
+  rdoc.options << "--exclude=lib/nmatrix/rspec.rb"
 end
 
 # vim: syntax=ruby

data/ext/nmatrix/data/data.cpp

@@ -88,7 +88,7 @@ namespace nm {
     "exp", "log2", 
     "log10", "sqrt", "erf", 
     "erfc", "cbrt", "gamma",
-    "negate", "floor", "ceil"
+    "negate", "floor", "ceil", "round"
   };
 
 } // end of namespace nm

data/ext/nmatrix/data/data.h

@@ -102,7 +102,8 @@ namespace nm {
     UNARY_GAMMA,
     UNARY_NEGATE,
     UNARY_FLOOR,
-    UNARY_CEIL
+    UNARY_CEIL,
+    UNARY_ROUND
   };
 
   // element-wise and scalar operators

data/ext/nmatrix/data/rational.h

@@ -56,9 +56,9 @@ namespace nm {
 
 template <typename Type> class Rational;
 
-typedef Rational<int16_t>	Rational32;
-typedef Rational<int32_t>	Rational64;
-typedef Rational<int64_t>	Rational128;
+typedef Rational<int16_t> Rational32;
+typedef Rational<int32_t> Rational64;
+typedef Rational<int64_t> Rational128;
 
 /*
  * Data
@@ -70,28 +70,28 @@ typedef Rational<int64_t>	Rational128;
 
 template <typename Type>
 class Rational {
-	public:
-	// The numerator and denominator of the rational number.
-	Type n;
-	Type d;
-	
-	/*
-	 * Default constructor.
-	 */
-	inline Rational(Type num = 0, Type den = 1) : n(num), d(den) {}
-	
-	/*
-	 * Copy constructors.
-	 */
-	template <typename OtherType>
-	inline Rational(const Rational<OtherType>& other) : n(other.n), d(other.d) {}
-
-	template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
-	inline Rational(const Complex<FloatType>& other) : n(0), d(1) {
-	  rb_raise(rb_eNotImpError, "cannot convert from complex to rational");
-	}
-
-	Rational(const RubyObject& other);
+  public:
+  // The numerator and denominator of the rational number.
+  Type n;
+  Type d;
+  
+  /*
+   * Default constructor.
+   */
+  inline Rational(Type num = 0, Type den = 1) : n(num), d(den) {}
+  
+  /*
+   * Copy constructors.
+   */
+  template <typename OtherType>
+  inline Rational(const Rational<OtherType>& other) : n(other.n), d(other.d) {}
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  inline Rational(const Complex<FloatType>& other) : n(0), d(1) {
+    rb_raise(rb_eNotImpError, "cannot convert from complex to rational");
+  }
+
+  Rational(const RubyObject& other);
 
   /*
    * Rational inverse function -- creates a copy, but inverted.
@@ -100,28 +100,28 @@ class Rational {
     return Rational<Type>(this->d, this->n);
   }
 
-	/*
-	 * Binary operator definitions for varous types.
-	 */
-
-	//////////////////////////////////
-	// Rational-Rational Operations //
-	//////////////////////////////////
-	
-	template <typename OtherType>
-	inline Rational<Type> operator+(const Rational<OtherType>& other) const {
-		Rational<Type> result((this->n * other.d) + (other.n * this->d), this->d * other.d);
-		
-		long simplify = gcf<Type>(result.n, result.d);
-
-		result.n /= simplify;
-		result.d /= simplify;
-		
-		return result;
-	}
-
-	template <typename OtherType>
-	inline Rational<Type>& operator+=(const Rational<OtherType>& other) {
+  /*
+   * Binary operator definitions for varous types.
+   */
+
+  //////////////////////////////////
+  // Rational-Rational Operations //
+  //////////////////////////////////
+  
+  template <typename OtherType>
+  inline Rational<Type> operator+(const Rational<OtherType>& other) const {
+    Rational<Type> result((this->n * other.d) + (other.n * this->d), this->d * other.d);
+    
+    long simplify = gcf<Type>(result.n, result.d);
+
+    result.n /= simplify;
+    result.d /= simplify;
+    
+    return result;
+  }
+
+  template <typename OtherType>
+  inline Rational<Type>& operator+=(const Rational<OtherType>& other) {
     this->n = (this->n * other.d) + (other.n * this->d);
     this->d = this->d * other.d;
 
@@ -131,22 +131,22 @@ class Rational {
     this->d /= simplify;
 
     return *this;
-	}
-	
-	template <typename OtherType>
-	inline Rational<Type> operator-(const Rational<OtherType>& other) const {
-		Rational<Type> result((this->n * other.d) - (other.n * this->d), this->d * other.d);
-		
-		long simplify = gcf<Type>(result.n, result.d);
-		
-		result.n /= simplify;
-		result.d /= simplify;
-		
-		return result;
-	}
-
-	template <typename OtherType>
-	inline Rational<Type>& operator-=(const Rational<OtherType>& other) {
+  }
+  
+  template <typename OtherType>
+  inline Rational<Type> operator-(const Rational<OtherType>& other) const {
+    Rational<Type> result((this->n * other.d) - (other.n * this->d), this->d * other.d);
+    
+    long simplify = gcf<Type>(result.n, result.d);
+    
+    result.n /= simplify;
+    result.d /= simplify;
+    
+    return result;
+  }
+
+  template <typename OtherType>
+  inline Rational<Type>& operator-=(const Rational<OtherType>& other) {
     this->n = (this->n * other.d) - (other.n * this->d);
     this->d = this->d * other.d;
 
@@ -156,19 +156,29 @@ class Rational {
     this->d /= simplify;
 
     return *this;
-	}
-	
-	template <typename OtherType>
-	inline Rational<Type> operator*(const Rational<OtherType>& other) const {
-		int g1 = gcf<Type>(this->n, other.d);
-		int g2 = gcf<Type>(this->d, other.n);
-		
-		return Rational<Type>((this->n / g1) * (other.n / g2), (this->d / g2) * (other.d / g1));
-	}
-
-
-	template <typename OtherType>
-	inline Rational<Type>& operator*=(const Rational<OtherType>& other) {
+  }
+  
+  template <typename OtherType>
+  inline Rational<Type> operator*(const Rational<OtherType>& other) const {
+    int g1 = gcf<Type>(this->n, other.d);
+    int g2 = gcf<Type>(this->d, other.n);
+  
+    return Rational<Type>((this->n / g1) * (other.n / g2), (this->d / g2) * (other.d / g1));
+  }
+
+  template <typename OtherType>
+  inline Rational<Type> operator/(const Rational<OtherType>& other) const {
+    Rational<Type> result = *this * Rational<OtherType>(other.d, other.n);
+
+    if (result.d < 0) { 
+      return Rational<Type>(-result.n, -result.d);
+    }
+
+    return result;
+  }
+
+  template <typename OtherType>
+  inline Rational<Type>& operator*=(const Rational<OtherType>& other) {
     int g1 = gcf<Type>(this->n, other.d);
     int g2 = gcf<Type>(this->d, other.n);
 
@@ -176,134 +186,128 @@ class Rational {
     this->d = (this->d / g2) * (other.d / g1);
 
     return *this;
-	}
-
-	
-	template <typename OtherType>
-	inline Rational<Type> operator/(const Rational<OtherType>& other) const {
-		return *this * Rational<OtherType>(other.d, other.n);
-	}
-
-	template <typename OtherType>
-	inline Rational<Type> operator/=(const Rational<OtherType>& other) {
-	  *this *= Rational<OtherType>(other.d, other.n);
-	  return *this;
-	}
-	
-	template <typename OtherType>
-	inline Rational<Type> operator%(const Rational<OtherType>& other) const {
-		long floor_div      = (this->n * other.n) / (this->d * other.d);
-		Rational<Type> prod	= other * Rational<long>(floor_div, 1);
-		
-		return Rational<long>(this->n, other.n) - prod;
-	}
-	
-	template <typename OtherType>
-	inline bool operator<(const Rational<OtherType>& other) const {
-		return (this->n * other.d) < (other.n * this->d);
-	}
-	
-	template <typename OtherType>
-	inline bool operator>(const Rational<OtherType>& other) const {
-		return (this->n * other.d) > (other.n * this->d);
-	}
-	
-	template <typename OtherType>
-	inline bool operator==(const Rational<OtherType>& other) const {
-		return (this->n == other.n) && (this->d == other.d);
-	}
-	
-	template <typename OtherType>
-	inline bool operator!=(const Rational<OtherType>& other) const {
-		return !(*this == other);
-	}
-	
-	template <typename OtherType>
-	inline bool operator<=(const Rational<OtherType>& other) const {
-		return (*this < other) || (*this == other);
-	}
-	
-	template <typename OtherType>
-	inline bool operator>=(const Rational<OtherType>& other) const {
-		return (*this > other) || (*this == other);
-	}
-	
-	template <typename OtherType>
-	inline operator Rational<OtherType> () const {
-		return Rational<OtherType>((OtherType)this->n, (OtherType)this->d);
-	}
-	
-	////////////////////////////////
-	// Rational-Native Operations //
-	////////////////////////////////
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline Rational<Type> operator+(const IntType& other) const {
-		return *this + Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline Rational<Type> operator-(const IntType& other) const {
-		return *this - Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline Rational<Type> operator*(const IntType& other) const {
-		return *this * Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline Rational<Type> operator/(const IntType& other) const {
-		return *this / Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline Rational<Type> operator%(const IntType& other) const {
-		return *this % Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator<(const IntType& other) const {
-		return *this < Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator>(const IntType& other) const {
-		return *this > Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator==(const IntType& other) const {
-		return *this == Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator!=(const IntType& other) const {
-		return *this != Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator<=(const IntType& other) const {
-		return *this <= Rational<Type>(other);
-	}
-	
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator>=(const IntType& other) const {
-		return *this >= Rational<Type>(other);
-	}
-	
-	template <typename NumType, typename = typename std::enable_if<std::is_arithmetic<NumType>::value>::type>
-	inline operator NumType () const {
-		return (NumType)this->n / (NumType)this->d;
-	}
-	
-	/*
-	 * Special casting operator for Complex numbers.
-	 */
-	template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
-	inline operator Rational<FloatType> () const {
-		return Rational<FloatType>(((FloatType)this->n) / ((FloatType)this->d));
-	}
+  }
+
+  template <typename OtherType>
+  inline Rational<Type> operator/=(const Rational<OtherType>& other) {
+    *this *= Rational<OtherType>(other.d, other.n);
+    return *this;
+  }
+  
+  template <typename OtherType>
+  inline Rational<Type> operator%(const Rational<OtherType>& other) const {
+    long floor_div      = (this->n * other.n) / (this->d * other.d);
+    Rational<Type> prod = other * Rational<long>(floor_div, 1);
+    
+    return Rational<long>(this->n, other.n) - prod;
+  }
+  
+  template <typename OtherType>
+  inline bool operator<(const Rational<OtherType>& other) const {
+    return (this->n * other.d) < (other.n * this->d);
+  }
+  
+  template <typename OtherType>
+  inline bool operator>(const Rational<OtherType>& other) const {
+    return (this->n * other.d) > (other.n * this->d);
+  }
+  
+  template <typename OtherType>
+  inline bool operator==(const Rational<OtherType>& other) const {
+    return (this->n == other.n) && (this->d == other.d);
+  }
+  
+  template <typename OtherType>
+  inline bool operator!=(const Rational<OtherType>& other) const {
+    return !(*this == other);
+  }
+  
+  template <typename OtherType>
+  inline bool operator<=(const Rational<OtherType>& other) const {
+    return (*this < other) || (*this == other);
+  }
+  
+  template <typename OtherType>
+  inline bool operator>=(const Rational<OtherType>& other) const {
+    return (*this > other) || (*this == other);
+  }
+  
+  template <typename OtherType>
+  inline operator Rational<OtherType> () const {
+    return Rational<OtherType>((OtherType)this->n, (OtherType)this->d);
+  }
+  
+  ////////////////////////////////
+  // Rational-Native Operations //
+  ////////////////////////////////
+
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline Rational<Type> operator+(const IntType& other) const {
+    return *this + Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline Rational<Type> operator-(const IntType& other) const {
+    return *this - Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline Rational<Type> operator*(const IntType& other) const {
+    return *this * Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline Rational<Type> operator/(const IntType& other) const {
+    return *this / Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline Rational<Type> operator%(const IntType& other) const {
+    return *this % Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline bool operator<(const IntType& other) const {
+    return *this < Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline bool operator>(const IntType& other) const {
+    return *this > Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline bool operator==(const IntType& other) const {
+    return *this == Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline bool operator!=(const IntType& other) const {
+    return *this != Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline bool operator<=(const IntType& other) const {
+    return *this <= Rational<Type>(other);
+  }
+  
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  inline bool operator>=(const IntType& other) const {
+    return *this >= Rational<Type>(other);
+  }
+  
+  template <typename NumType, typename = typename std::enable_if<std::is_arithmetic<NumType>::value>::type>
+  inline operator NumType () const {
+    return (NumType)this->n / (NumType)this->d;
+  }
+  
+  /*
+   * Special casting operator for Complex numbers.
+   */
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  inline operator Rational<FloatType> () const {
+    return Rational<FloatType>(((FloatType)this->n) / ((FloatType)this->d));
+  }
 };
 
 // Negative operator
@@ -322,22 +326,22 @@ inline Rational<Type> operator-(const Rational<Type>& rhs) {
 
 template <typename IntType, typename RationalType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
 inline Rational<RationalType> operator+(const IntType& left, const Rational<RationalType>& right) {
-	return Rational<RationalType>(left) + right;
+  return Rational<RationalType>(left) + right;
 }
 
 template <typename IntType, typename RationalType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
 inline Rational<RationalType> operator-(const IntType& left, const Rational<RationalType>& right) {
-	return Rational<RationalType>(left) - right;
+  return Rational<RationalType>(left) - right;
 }
 
 template <typename IntType, typename RationalType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
 inline Rational<RationalType> operator*(const IntType& left, const Rational<RationalType>& right) {
-	return Rational<RationalType>(left) * right;
+  return Rational<RationalType>(left) * right;
 }
 
 template <typename IntType, typename RationalType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
 inline Rational<RationalType> operator/(const IntType& left, const Rational<RationalType>& right) {
-	return Rational<RationalType>(left) / right;
+  return Rational<RationalType>(left) / right;
 }
 
 /*
@@ -346,22 +350,22 @@ inline Rational<RationalType> operator/(const IntType& left, const Rational<Rati
 
 template <typename FloatType, typename RationalType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
 inline FloatType operator+(const FloatType& left, const Rational<RationalType>& right) {
-	return left + (FloatType)right;
+  return left + (FloatType)right;
 }
 
 template <typename FloatType, typename RationalType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
 inline FloatType operator-(const FloatType& left, const Rational<RationalType>& right) {
-	return left - (FloatType)right;
+  return left - (FloatType)right;
 }
 
 template <typename FloatType, typename RationalType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
 inline FloatType operator*(const FloatType& left, const Rational<RationalType>& right) {
-	return left * (FloatType)right;
+  return left * (FloatType)right;
 }
 
 template <typename FloatType, typename RationalType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
 inline FloatType operator/(const FloatType& left, const Rational<RationalType>& right) {
-	return left / (FloatType)right;
+  return left / (FloatType)right;
 }
 
 /*
@@ -370,44 +374,44 @@ inline FloatType operator/(const FloatType& left, const Rational<RationalType>&
 
 template <typename NativeType, typename RationalType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
 inline bool operator<(const NativeType left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) < right;
-	return (left * right.d) < right.n;
+  //return Rational<RationalType>(left) < right;
+  return (left * right.d) < right.n;
 }
 
 template <typename NativeType, typename RationalType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
 inline bool operator>(const NativeType left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) > right;
-	return (left * right.d) > right.n;
+  //return Rational<RationalType>(left) > right;
+  return (left * right.d) > right.n;
 }
 
 template <typename IntType, typename RationalType>
 inline bool operator==(const typename std::enable_if<std::is_integral<IntType>::value, IntType>::type left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) == right;
-	return (left * right.d) == right.n;
+  //return Rational<RationalType>(left) == right;
+  return (left * right.d) == right.n;
 }
 
 template <typename FloatType, typename RationalType>
 inline bool operator==(const typename std::enable_if<std::is_floating_point<FloatType>::value, FloatType>::type left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) == right;
-	return FP_EQUAL(left, ((FloatType)right));
+  //return Rational<RationalType>(left) == right;
+  return FP_EQUAL(left, ((FloatType)right));
 }
 
 template <typename NativeType, typename RationalType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
 inline bool operator!=(const NativeType left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) != right;
-	return !(left == right);
+  //return Rational<RationalType>(left) != right;
+  return !(left == right);
 }
 
 template <typename NativeType, typename RationalType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
 inline bool operator<=(const NativeType left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) <= right;
-	return (left < right) or (left == right);
+  //return Rational<RationalType>(left) <= right;
+  return (left < right) or (left == right);
 }
 
 template <typename NativeType, typename RationalType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
 inline bool operator>=(const NativeType left, const Rational<RationalType>& right) {
-	//return Rational<RationalType>(left) >= right;
-	return (left > right) or (left == right); 
+  //return Rational<RationalType>(left) >= right;
+  return (left > right) or (left == right); 
 }
 
 template <typename Type>