nmatrix-gemv 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ae23439e8353af4cb448484f3fbfda6b48b2298
+  data.tar.gz: 62438a8e9422b60195513cda83899d38996bba36
+SHA512:
+  metadata.gz: bd9f765529f35717cccdae8ecf222c0a04cddf60ff502ef2b4713ee470bb20f7e267a568d40802604c4796db4c2b68ada80b4156e1e7a82dd222fb32a387572f
+  data.tar.gz: 370c1440f3bae1bb28b85823e509204f35cb24db7a5eedcfd7538d4cf4a6eda8eb6238e38364ce16c43eac4b2bfacf58328e6241c35b82622502bc5a4ada997f

data/.gitignore

@@ -0,0 +1,29 @@
+.idea
+Gemfile.lock
+ext/nmatrix/dense/daxpy.c
+ext/nmatrix/dense/dgeco.c
+ext/nmatrix/dense/dgefa.c
+ext/nmatrix/dense/dgemm.c
+ext/nmatrix/dense/dgemv.c
+ext/nmatrix/dense/dscal.c
+ext/nmatrix/dense/idamax.c
+ext/nmatrix/dense/467.c
+ext/nmatrix/dense/*.f
+ext/nmatrix/dense/transpose.txt
+ext/nmatrix/yale/aicm.tex
+tmp/
+test.c
+spec/*.mtx
+*.o
+*.so
+*.bundle
+*.bundle.dSYM
+*.log
+/tags
+*.gem
+html/
+doc/
+docs/
+pkg/
+.autotest
+tags

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format RSpec::Longrun::Formatter

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+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"
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libatlas-base-dev
+script: bundle exec rake compile && bundle exec rake spec
+

data/Gemfile

@@ -0,0 +1,7 @@
+# Gemfile
+source 'http://ruby.taobao.org/'
+gemspec
+
+group :development do
+  gem 'rspec-longrun'
+end

data/README.md

@@ -0,0 +1,29 @@
+# nmatrix-gemv #
+
+## How to install ##
+`bundle install`
+
+`bundle exec rake compile`
+
+`gem build nmatrix-gemv.gemspec`
+
+`gem install ./nmatrix-gemv-0.0.2.gem`
+
+## How to use ##
+```
+irb
+>require 'nmatrix-gemv'
+=> true
+```
+### In file: ###
+Suppose you have [NMatrix](https://github.com/SciRuby/nmatrix) installed.
+
+```{.ruby}
+require 'nmatrix'
+require 'nmatrix-gemv'
+
+a = NMatrix.new([2,3], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0], dtype: :float64)
+x = NMatrix.new([1,4], [2.0, 3.0, 4.0, 5.0], dtype: :float64)
+
+NMatrix::BLAS.gemv(a, x)
+```

data/Rakefile

@@ -0,0 +1,225 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'rubygems/package_task'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require "rake/extensiontask"
+Rake::ExtensionTask.new do |ext|
+    ext.name = 'nmatrix_gemv'          
+    ext.ext_dir = 'ext/nmatrix_gemv' 
+    ext.lib_dir = 'lib/'             
+    ext.source_pattern = "**/*.{c,cpp, h}" 
+end
+
+gemspec = eval(IO.read("nmatrix-gemv.gemspec"))
+=begin
+Gem::PackageTask.new(gemspec).define
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{gem install pkg/nmatrix-#{NMatrix::VERSION}.gem}
+end
+=end
+
+require 'rspec/core/rake_task'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb'].uniq
+end
+
+
+BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
+SPECDIR = BASEDIR + 'spec'
+
+VALGRIND_OPTIONS = [
+    "--tool=memcheck",
+    #"--leak-check=yes",
+    "--num-callers=15",
+    #"--error-limit=no",
+    "--partial-loads-ok=yes",
+    "--undef-value-errors=no" #,
+    #"--dsymutil=yes"
+]
+
+CALLGRIND_OPTIONS = [
+    "--tool=callgrind",
+    "--dump-instr=yes",
+    "--simulate-cache=yes",
+    "--collect-jumps=yes"
+]
+
+VALGRIND_MEMORYFILL_OPTIONS = [
+    "--freelist-vol=100000000",
+    "--malloc-fill=6D",
+    "--free-fill=66 ",
+]
+
+GDB_OPTIONS = []
+
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :console do |task|
+  cmd = [ 'irb', "-r './lib/nmatrix_gemv.rb'" ]
+  run *cmd
+end
+
+=begin
+task :pry do |task|
+  cmd = [ 'pry', "-r './lib/nmatrix.rb'" ]
+  run *cmd
+end
+
+
+namespace :pry do
+  task :valgrind => [ :compile ] do |task|
+    cmd  = [ 'valgrind' ] + VALGRIND_OPTIONS
+    cmd += ['ruby', '-Ilib:ext', "-r './lib/nmatrix.rb'", "-r 'pry'", "-e 'binding.pry'"]
+    run *cmd
+  end
+end
+=end
+
+namespace :console do
+  CONSOLE_CMD = ['irb', "-r './lib/nmatrix_gemv.rb'"]
+  desc "Run console under GDB."
+  task :gdb => [ :compile ] do |task|
+          cmd = [ 'gdb' ] + GDB_OPTIONS
+          cmd += [ '--args' ]
+          cmd += CONSOLE_CMD
+          run( *cmd )
+  end
+
+  desc "Run console under Valgrind."
+  task :valgrind => [ :compile ] do |task|
+          cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+          cmd += CONSOLE_CMD
+          run( *cmd )
+  end
+end
+
+task :default => :spec
+
+def run *cmd
+  sh(cmd.join(" "))
+end
+
+namespace :spec do
+  # partial-loads-ok and undef-value-errors necessary to ignore
+  # spurious (and eminently ignorable) warnings from the ruby
+  # interpreter
+
+  RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', SPECDIR.to_s ]
+
+  #desc "Run the spec for generator.rb"
+  #task :generator do |task|
+  #  run 'rspec spec/generator_spec.rb'
+  #end
+
+  desc "Run specs under GDB."
+  task :gdb => [ :compile ] do |task|
+          cmd = [ 'gdb' ] + GDB_OPTIONS
+    cmd += [ '--args' ]
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under cgdb."
+  task :cgdb => [ :compile ] do |task|
+    cmd = [ 'cgdb' ] + GDB_OPTIONS
+    cmd += [ '--args' ]
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under Valgrind."
+  task :valgrind => [ :compile ] do |task|
+    cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under Callgrind."
+  task :callgrind => [ :compile ] do |task|
+    cmd = [ 'valgrind' ] + CALLGRIND_OPTIONS
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+end
+
+=begin
+LEAKCHECK_CMD = [ 'ruby', '-Ilib:ext', "#{SPECDIR}/leakcheck.rb" ]
+
+
+desc "Run leakcheck script."
+task :leakcheck => [ :compile ] do |task|
+  cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+  cmd += LEAKCHECK_CMD
+  run( *cmd )
+end
+=end
+
+namespace :clean do
+  task :so do |task|
+    tmp_path = "tmp/#{RUBY_PLATFORM}/nmatrix-gemv/#{RUBY_VERSION}"
+    chdir tmp_path do
+      if RUBY_PLATFORM =~ /mswin/
+        `nmake soclean`
+      else
+        mkcmd = ENV['MAKE'] || %w[gmake make].find { |c| system("#{c} -v >> /dev/null 2>&1") }
+        `#{mkcmd} soclean`
+      end
+    end
+  end
+end
+
+=begin
+desc "Check the manifest for correctness"
+task :check_manifest do |task|
+  manifest_files  = File.read("Manifest.txt").split
+
+  git_files       = `git ls-files |grep -v 'spec/'`.split
+  ignore_files    = %w{.gitignore .rspec ext/nmatrix/binary_format.txt ext/nmatrix/ttable_helper.rb scripts/mac-brew-gcc.sh}
+
+  possible_files  = git_files - ignore_files
+
+  missing_files   = possible_files - manifest_files
+  extra_files     = manifest_files - possible_files
+
+  unless missing_files.empty?
+    STDERR.puts "The following files are in the git repo but not the Manifest:"
+    missing_files.each { |f| STDERR.puts " -- #{f}"}
+  end
+
+  unless extra_files.empty?
+    STDERR.puts "The following files are in the Manifest but may not be necessary:"
+    extra_files.each { |f| STDERR.puts " -- #{f}"}
+  end
+
+  if extra_files.empty? && missing_files.empty?
+    STDERR.puts "Manifest looks good!"
+  end
+
+end
+=end
+
+=begin
+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})
+end
+=end
+
+# vim: syntax=ruby

data/ext/nmatrix_gemv/binary_format.txt

@@ -0,0 +1,53 @@
+This is the proposed binary format for saving and loading NMatrix objects.
+
+Order is little-endian.
+
+List matrices should be converted to dense or yale matrices. There should be no serious need to load or save
+linked-list matrices, since these exist primarily in order to construct efficient yale matrices.
+
+
+First 64-bit block:
+* ui16 major (version)
+* ui16 minor
+* ui16 release
+* i16 NULL
+
+
+Second 64-bit block:
+* ui8 dtype
+* ui8 stype
+* ui8 itype # ui32 for dense
+* ui8 symm
+* i16 NULL
+* ui16 dim    # if 1, NVector; otherwise, NMatrix
+
+
+3rd - nth 64-bit block: shape
+
+itype sets the number of bytes allocated for each shape entry. Since only yale uses itype, dense will pretty
+much always be the UINT32 itype (see nmatrix.h). If the total number of bytes occupied by the shape array is
+less than 8, the rest of the 64-bit block will be padded with zeros.
+
+
+(n+1)th 64-bit block: depends on stype, symm
+
+symm is designed to reduce file size by allowing us to not save certain elements in symmetric, hermitian, skew-
+symmetric, and triangular matrices. These values will be defined in nmatrix.h; 0 indicates standard (no symmetry).
+In later versions, additional patterns may be defined which might even have less to do with symmetry than
+upper/lower do.
+
+When storing a symmetric matrix, we will only store the upper portion. If the matrix is lower triangular, only the
+lower portion will be stored.
+
+For dense, we simply store the contents of the matrix exactly as in memory (or just the upper-triangular part if
+symm is set).
+
+For yale, we store:
+* ui32 ndnz
+* ui32 length (AKA size, the number of elements in A/IJA that aren't nil/undefined)
+
+The latter will serve as the capacity when we read a Yale matrix.
+
+Then we store the a array, again padding with zeros so it's a multiple of 8 bytes.
+
+Then we store the ija array, padding with zeros so it's a multiple of 8 bytes.

data/ext/nmatrix_gemv/data/complex.h

@@ -0,0 +1,399 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == complex.h
+//
+// Functions and classes for dealing with complex numbers.
+
+#ifndef COMPLEX_H
+#define COMPLEX_H
+
+/*
+ * Standard Includes
+ */
+
+#include <type_traits>
+#include <iostream>
+#include <cmath>
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+namespace nm {
+
+class RubyObject;
+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(const RubyObject& other);
+
+  /*
+   * 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 = 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 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;
+}
+
+// Negative operator
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline Complex<IntType> operator-(const Complex<IntType>& rhs) {
+  return Complex<IntType>(-rhs.r, -rhs.i);
+}
+
+} // end of namespace nm
+
+namespace std {
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  nm::Complex<FloatType> piecewise_abs(const nm::Complex<FloatType>& value) {
+    return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
+                                  value.i < 0 ? -value.i : value.i);
+  }
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  nm::Complex<FloatType> real_abs(const nm::Complex<FloatType>& value) {
+    return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
+                                  value.i);
+  }
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  nm::Complex<FloatType> imag_abs(const nm::Complex<FloatType>& value) {
+    return nm::Complex<FloatType>(value.r,
+                                  value.i < 0 ? -value.i : value.i);
+  }
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  double abs(const nm::Complex<FloatType>& value) {
+    return std::sqrt(double(value.r)*double(value.r) + double(value.i)*double(value.i));
+  }
+}
+
+#endif // COMPLEX_H