nmatrix 0.0.1 → 0.0.2

data/ext/nmatrix/data/ruby_object.h

@@ -0,0 +1,446 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == ruby_object.h
+//
+// Functions and classes for dealing with Ruby objects.
+
+#ifndef RUBY_OBJECT_H
+#define RUBY_OBJECT_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <iostream>
+#include <type_traits>
+
+/*
+ * Project Includes
+ */
+
+#include "ruby_constants.h"
+
+/*
+ * Macros
+ */
+#define NM_RUBYVAL_IS_NUMERIC(val)                (FIXNUM_P(val) or (TYPE(val) == T_FLOAT) or (TYPE(val) == T_COMPLEX) or (TYPE(val) == T_RATIONAL))
+#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.");
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+
+/*
+ * Classes and Functions
+ */
+namespace nm {
+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 {};
+
+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))) {}
+	
+	/*
+	 * Rational number constructor.
+	 */
+	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+	inline RubyObject(const Rational<IntType>& other) : rval(rb_rational_new(INT2FIX(other.n), INT2FIX(other.d))) {}
+	
+	/*
+	 * 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)) {}
+	
+  /*
+	 * 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) {
+    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) {
+    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) {
+    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) {
+    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 //
+	////////////////////////////
+/*
+	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);
+	}
+*/
+	//////////////////////////////
+	// RUBY-RATIONAL OPERATIONS //
+	//////////////////////////////
+
+	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+	inline bool operator==(const Rational<IntType>& other) const {
+		return *this == RubyObject(other);
+	}
+
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+	inline bool operator!=(const Rational<IntType>& other) const {
+		return *this != RubyObject(other);
+	}
+
+	//////////////////////////////
+	// 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);
+	}
+
+	/*
+	 * 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) {
+		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT or TYPE(this->rval) == T_RATIONAL) {
+			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.");
+		}
+	}
+	
+	/*
+	 * Convert a Ruby object to a rational number.
+	 */
+	template <typename RationalType>
+	inline typename std::enable_if<made_from_same_template<RationalType, Rational32>::value, RationalType>::type to(void) {
+		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT or TYPE(this->rval) == T_COMPLEX) {
+			return RationalType(NUM2INT(this->rval));
+			
+		} else if (TYPE(this->rval) == T_RATIONAL) {
+			return RationalType(NUM2INT(rb_funcall(this->rval, nm_rb_numer, 0)), NUM2INT(rb_funcall(this->rval, nm_rb_denom, 0)));
+			
+		} else {
+			rb_raise(rb_eTypeError, "Invalid conversion to Rational type.");
+		}
+	}
+	
+	template <typename OtherType>
+	inline operator OtherType () {
+		return to<OtherType>();
+	}
+};
+
+
+////////////////////////////
+// NATIVE-RUBY OPERATIONS //
+////////////////////////////
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline RubyObject operator/(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) / right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator==(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) == right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator!=(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) != right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator<=(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) <= right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator>=(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) >= right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator<(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) < right;
+}
+
+template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
+inline bool operator>(const NativeType left, const RubyObject& right) {
+  return RubyObject(left) > right;
+}
+
+
+/////////////////////////////
+// COMPLEX-RUBY OPERATIONS //
+/////////////////////////////
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+
+
+//////////////////////////////
+// RATIONAL-RUBY OPERATIONS //
+//////////////////////////////
+
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator==(const Rational<IntType>& left, const RubyObject& right) {
+	return RubyObject(left) == right;
+}
+
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator!=(const Rational<IntType>& left, const RubyObject& right) {
+	return RubyObject(left) != right;
+}
+
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator>=(const Rational<IntType>& left, const RubyObject& right) {
+	return RubyObject(left) >= right;
+}
+
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator<=(const Rational<IntType>& left, const RubyObject& right) {
+	return RubyObject(left) <= right;
+}
+
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator<(const Rational<IntType>& left, const RubyObject& right) {
+	return RubyObject(left) < right;
+}
+
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline bool operator>(const Rational<IntType>& left, const RubyObject& right) {
+	return RubyObject(left) > right;
+}
+
+inline std::ostream& operator<<(std::ostream& out, const RubyObject& rhs) {
+  out << "RUBYOBJECT" << std::flush; // FIXME: Try calling inspect or something on the Ruby object if we really need to debug it.
+  return out;
+}
+
+} // end of namespace nm
+
+namespace std {
+  inline nm::RubyObject abs(const nm::RubyObject& obj) {
+    return obj.abs();
+  }
+}
+
+#endif // RUBY_OBJECT_H

data/ext/nmatrix/extconf.rb

@@ -22,11 +22,13 @@
 #
 # == extconf.rb
 #
-# This file mostly derived from NArray.
+# This file checks for ATLAS and other necessary headers, and
+# generates a Makefile for compiling NMatrix.
 
 require "mkmf"
 
 
+# Function derived from NArray's extconf.rb.
 def have_type(type, header=nil)
   printf "checking for %s... ", type
   STDOUT.flush
@@ -57,20 +59,30 @@ SRC
   return true
 end
 
+# Function derived from NArray's extconf.rb.
 def create_conf_h(file)
   print "creating #{file}\n"
-  hfile = open(file, "w")
-  for line in $defs
-    line =~ /^-D(.*)/
-    hfile.printf "#define %s 1\n", $1
+  File.open(file, 'w') do |hfile|
+  	header_guard = file.upcase.sub(/\s|\./, '_')
+		
+		hfile.puts "#ifndef #{header_guard}"
+		hfile.puts "#define #{header_guard}"
+		hfile.puts
+		
+		for line in $defs
+		  line =~ /^-D(.*)/
+		  hfile.printf "#define %s 1\n", $1
+		end
+		
+		hfile.puts
+		hfile.puts "#endif"
   end
-  hfile.close
 end
 
 if RUBY_VERSION < '1.9'
   raise(NotImplementedError, "Sorry, you need Ruby 1.9!")
 else
-  $INSTALLFILES = [['nmatrix.h', '$(archdir)'], ['nmatrix_config.h', '$(archdir)']]
+  $INSTALLFILES = [['nmatrix.h', '$(archdir)'], ['nmatrix.hpp', '$(archdir)'], ['nmatrix_config.h', '$(archdir)']]
   if /cygwin|mingw/ =~ RUBY_PLATFORM
 	 $INSTALLFILES << ['libnmatrix.a', '$(archdir)']
   end
@@ -81,63 +93,101 @@ if /cygwin|mingw/ =~ RUBY_PLATFORM
 end
 
 $DEBUG = true
-$CFLAGS = ["-Wall ",$CFLAGS].join(" ") #-BENCHMARK for comparing transp
-
-srcs = %w(
-nmatrix
-list
-dense
-yale
-dfuncs
-smmp1
-smmp2
-cblas
-blas
-rational
-)
+$CFLAGS = ["-Wall ",$CFLAGS].join(" ")
+
+$srcs = [
+	'nmatrix.cpp',
+	'ruby_constants.cpp',
+
+	'data/data.cpp',
+	'util/math.cpp',
+  'util/sl_list.cpp',
+  'util/io.cpp',
+  'storage/common.cpp',
+	'storage/storage.cpp',
+	'storage/dense.cpp',
+  'storage/yale.cpp',
+  'storage/list.cpp'
+]
 # add smmp in to get generic transp; remove smmp2 to eliminate funcptr transp
 
-header = "stdint.h"
-unless have_header(header)
-  header = "sys/types.h"
-  unless have_header(header)
-    header = nil
-  end
-end
+# The next line allows the user to supply --with-atlas-include=/usr/local/atlas, for example,
+# and tell the compiler where to look for ATLAS.
+dir_config("atlas")
 
-have_type("u_int8_t", header)
-have_type("uint8_t", header)
-have_type("u_int16_t", header)
-have_type("uint16_t", header)
-have_type("int16_t", header)
-have_type("int32_t", header)
-have_type("u_int32_t", header)
-have_type("uint32_t", header)
-have_type("int64_t", header)
-have_type("u_int64_t", header)
-have_type("uint64_t", header)
-
-unless have_type("size_t", header)
-  have_type("size_t", "stddef.h")
-end
+# Is g++ having trouble finding your header files?
+# Try this:
+#   export C_INCLUDE_PATH=/usr/local/atlas/include
+#   export CPLUS_INCLUDE_PATH=/usr/local/atlas/include
+# (substituting in the path of your cblas.h and clapack.h for the path I used). -- JW 8/27/12
 
-# dir_config("cblas")
-# dir_config("atlas")
+find_library("lapack", "clapack_dgetrf", "/usr/local/lib", "/usr/local/atlas/lib")
+have_header("clapack.h")
 
 find_library("cblas", "cblas_dgemm", "/usr/local/lib", "/usr/local/atlas/lib")
 find_library("atlas", "ATL_dgemmNN", "/usr/local/lib", "/usr/local/atlas/lib", "/usr/lib")
-find_header("cblas.h", "/usr/local/include", "/usr/local/atlas/include")
+have_header("cblas.h")
 
-have_library("f2c")
-have_header("f2c.h")
+# Order matters here: ATLAS has to go after LAPACK: http://mail.scipy.org/pipermail/scipy-user/2007-January/010717.html
+$libs += " -llapack -lcblas -latlas "
 
+$objs = %w{nmatrix ruby_constants data/data util/io util/math util/sl_list storage/common storage/storage storage/dense storage/yale storage/list}.map { |i| i + ".o" }
 
-$libs += " -lcblas -latlas "
+#CONFIG['CXX'] = 'clang++'
+CONFIG['CXX'] = 'g++'
 
-$objs = srcs.collect{|i| i+".o" }
+def find_newer_gplusplus
+  [7,6,5,4,3].each do |minor|
+    result = `which g++-4.#{minor}`
+    next if result.empty?
+    CONFIG['CXX'] = "g++-4.#{minor}"
+    return CONFIG['CXX']
+  end
+  false
+end
+
+def gplusplus_version
+  `#{CONFIG['CXX']} -v 2>&1`.lines.to_a.last.match(/gcc\sversion\s(\d\.\d.\d)/).captures.first
+end
 
-$CFLAGS += " -O0"
+
+if CONFIG['CXX'] == 'clang++'
+	$CPP_STANDARD = 'c++11'
+
+else
+	version = gplusplus_version
+  if version < '4.3.0' && CONFIG['CXX'] == 'g++'  # see if we can find a newer G++, unless it's been overridden by user
+    if !find_newer_gplusplus
+      raise("You need a version of g++ which supports -std=c++0x or -std=c++11. If you're on a Mac and using Homebrew, we recommend using mac-brew-gcc.sh to install a more recent g++.")
+    end
+    version = gplusplus_version
+  end
+
+	if version < '4.7.0'
+		$CPP_STANDARD = 'c++0x'
+	else
+		$CPP_STANDARD = 'c++11'
+	end
+end
+
+# For release, these next two should both be changed to -O3.
+$CFLAGS += " -O0 "
+$CPPFLAGS += " -O0 -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
+
+CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
 
 create_conf_h("nmatrix_config.h")
 create_makefile("nmatrix")
 
+Dir.mkdir("data") unless Dir.exists?("data")
+Dir.mkdir("util") unless Dir.exists?("util")
+Dir.mkdir("storage") unless Dir.exists?("storage")
+
+# to clean up object files in subdirectories:
+open('Makefile', 'a') do |f|
+  f.write <<EOS
+CLEANOBJS := $(CLEANOBJS) data/*.#{CONFIG["OBJEXT"]} storage/*.#{CONFIG["OBJEXT"]} util/*.#{CONFIG["OBJEXT"]}
+EOS
+end