nmatrix 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 862e6785562317ff3ffe71dfa679ab58d3bfd219
-  data.tar.gz: 428075f3287f76f862bda8dbf6efa837272e6db9
+  metadata.gz: 8dd60ade9441cfcdc2c70cd18a60571110c18145
+  data.tar.gz: 3ae0a112c051f510718a2d7afad97327bb6808c2
 SHA512:
-  metadata.gz: 3d845e422a71670756115bb9a9c6eb6c448b89c08f471395a4ffec74b71bdb4052732df7e619aabc1f5a825b5e2c8f36cc215aaa4b1b20192c1575729a5698e2
-  data.tar.gz: 8737125b9d9778afa68ee7ac195014f286d29bea4fc7d33081a14610995e6df312fd2767a56207352534b718ae1c361a4c9ff2a5ad289043c091e4687be0fec9
+  metadata.gz: 6d9fcb8e0ba7ebb62cd30fa7aba1aafe0bcf1dba7ce7e77a12f3e249280212c668313c94b3e80ce40528829061ef0a6e8b140eda8d8f66175023133712393f72
+  data.tar.gz: ba0a384a026c56c01595b7de0b3a3a741bbe021d2b44e358a14c8f5d665c020262d0b400f6eade6a20ee91d65f90e47d730cc015430db5a0539ad4d684ceb6eb

data/ext/nmatrix/data/data.cpp

@@ -198,39 +198,39 @@ 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:
+    case nm::BYTE:
       *reinterpret_cast<uint8_t*>(loc)      = static_cast<uint8_t>(RubyObject(val));
       break;
 
-    case INT8:
+    case nm::INT8:
       *reinterpret_cast<int8_t*>(loc)        = static_cast<int8_t>(RubyObject(val));
       break;
 
-    case INT16:
+    case nm::INT16:
       *reinterpret_cast<int16_t*>(loc)      = static_cast<int16_t>(RubyObject(val));
       break;
 
-    case INT32:
+    case nm::INT32:
       *reinterpret_cast<int32_t*>(loc)      = static_cast<int32_t>(RubyObject(val));
       break;
 
-    case INT64:
+    case nm::INT64:
       *reinterpret_cast<int64_t*>(loc)      = static_cast<int64_t>(RubyObject(val));
       break;
 
-    case FLOAT32:
+    case nm::FLOAT32:
       *reinterpret_cast<float32_t*>(loc)    = static_cast<float32_t>(RubyObject(val));
       break;
 
-    case FLOAT64:
+    case nm::FLOAT64:
       *reinterpret_cast<float64_t*>(loc)    = static_cast<float64_t>(RubyObject(val));
       break;
 
-    case COMPLEX64:
+    case nm::COMPLEX64:
       *reinterpret_cast<Complex64*>(loc)    = RubyObject(val).to<Complex64>();
       break;
 
-    case COMPLEX128:
+    case nm::COMPLEX128:
       *reinterpret_cast<Complex128*>(loc)    = RubyObject(val).to<Complex128>();
       break;
 

data/ext/nmatrix/data/data.h

@@ -121,18 +121,17 @@ namespace nm {
 
   template <typename Type>
   Complex<Type>& Complex<Type>::operator=(const RubyObject& other) {
-    switch(TYPE(other.rval)) {
-    case T_COMPLEX:
+    if (RB_TYPE_P(other.rval, T_COMPLEX)) {
       this->r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
       this->i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
-      break;
-    case T_FLOAT:
-    case T_FIXNUM:
-    case T_BIGNUM:
+    }
+    else if (RB_TYPE_P(other.rval, T_FLOAT) ||
+             RB_TYPE_P(other.rval, T_FIXNUM) ||
+             RB_TYPE_P(other.rval, T_BIGNUM)) {
       this->r = NUM2DBL(other.rval);
       this->i = 0.0;
-      break;
-    default:
+    }
+    else {
       rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
     }
     return *this;

data/ext/nmatrix/data/ruby_object.h

@@ -45,10 +45,7 @@
 /*
  * Macros
  */
-#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.");
+#define NM_RUBYVAL_IS_NUMERIC(val)                (FIXNUM_P(val) or RB_FLOAT_TYPE_P(val) or RB_TYPE_P(val, T_COMPLEX))
 
 /*
  * Classes and Functions

data/ext/nmatrix/extconf.rb

@@ -25,74 +25,18 @@
 # This file checks for ATLAS and other necessary headers, and
 # generates a Makefile for compiling NMatrix.
 
-require "mkmf"
+require File.expand_path("../../../lib/nmatrix/mkmf", __FILE__)
 
-
-# Function derived from NArray's extconf.rb.
-def have_type(type, header=nil) #:nodoc:
-  printf "checking for %s... ", type
-  STDOUT.flush
-
-  src = <<"SRC"
-#include <ruby.h>
-SRC
-
-
-  src << <<"SRC" unless header.nil?
-#include <#{header}>
-SRC
-
-  r = try_link(src + <<"SRC")
-  int main() { return 0; }
-  int t() { #{type} a; return 0; }
-SRC
-
-  unless r
-    print "no\n"
-    return false
-  end
-
-  $defs.push(format("-DHAVE_%s", type.upcase))
-
-  print "yes\n"
-
-  return true
-end
-
-# Function derived from NArray's extconf.rb.
-def create_conf_h(file) #:nodoc:
-  print "creating #{file}\n"
-  File.open(file, 'w') do |hfile|
-    header_guard = file.upcase.sub(/\s|\./, '_')
-
-    hfile.puts "#ifndef #{header_guard}"
-    hfile.puts "#define #{header_guard}"
-    hfile.puts
-
-    # FIXME: Find a better way to do this:
-    hfile.puts "#define RUBY_2 1" if RUBY_VERSION >= '2.0'
-
-    for line in $defs
-      line =~ /^-D(.*)/
-      hfile.printf "#define %s 1\n", $1
-    end
-
-    hfile.puts
-    hfile.puts "#endif"
-  end
-end
-
-if RUBY_VERSION < '1.9'
-  raise(NotImplementedError, "Sorry, you need at least Ruby 1.9!")
-else
-  $INSTALLFILES = [['nmatrix.h', '$(archdir)'], ['nmatrix.hpp', '$(archdir)'], ['nmatrix_config.h', '$(archdir)'], ['nm_memory.h', '$(archdir)']]
-  if /cygwin|mingw/ =~ RUBY_PLATFORM
-    $INSTALLFILES << ['libnmatrix.a', '$(archdir)']
-  end
-end
+$INSTALLFILES = [
+  ['nmatrix.h'       , '$(archdir)'], 
+  ['nmatrix.hpp'     , '$(archdir)'],
+  ['nmatrix_config.h', '$(archdir)'], 
+  ['nm_memory.h'     , '$(archdir)'],
+  ['ruby_constants.h', '$(archdir)']
+]
 
 if /cygwin|mingw/ =~ RUBY_PLATFORM
-  CONFIG["DLDFLAGS"] << " --output-lib libnmatrix.a"
+  $INSTALLFILES << ['libnmatrix.a', '$(archdir)']
 end
 
 $DEBUG = true
@@ -105,70 +49,8 @@ basenames = %w{nmatrix ruby_constants data/data util/io math util/sl_list storag
 $objs = basenames.map { |b| "#{b}.o"   }
 $srcs = basenames.map { |b| "#{b}.cpp" }
 
-def find_newer_gplusplus #:nodoc:
-  print "checking for apparent GNU g++ binary with C++0x/C++11 support... "
-  [9,8,7,6,5,4,3].each do |minor|
-    ver = "4.#{minor}"
-    gpp = "g++-#{ver}"
-    result = `which #{gpp}`
-    next if result.empty?
-    CONFIG['CXX'] = gpp
-    puts ver
-    return CONFIG['CXX']
-  end
-  false
-end
-
-def gplusplus_version
-  cxxvar = proc { |n| `#{CONFIG['CXX']} -E -dM - </dev/null | grep #{n}`.chomp.split(' ')[2] }
-  major = cxxvar.call('__GNUC__')
-  minor = cxxvar.call('__GNUC_MINOR__')
-  patch = cxxvar.call('__GNUC_PATCHLEVEL__')
-
-  raise("unable to determine g++ version (match to get version was nil)") if major.nil? || minor.nil? || patch.nil?
-
-  "#{major}.#{minor}.#{patch}"
-end
-
-
-if CONFIG['CXX'] == 'clang++'
-  $CXX_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'
-    $CXX_STANDARD = 'c++0x'
-  else
-    $CXX_STANDARD = 'c++11'
-  end
-  puts "using C++ standard... #{$CXX_STANDARD}"
-  puts "g++ reports version... " + `#{CONFIG['CXX']} --version|head -n 1|cut -f 3 -d " "`
-end
-
 #$libs += " -lprofiler "
 
-# For release, these next two should both be changed to -O3.
-$CFLAGS += " -O3 "
-#$CFLAGS += " -static -O0 -g "
-$CXXFLAGS += " -O3 -std=#{$CXX_STANDARD} " #-fmax-errors=10 -save-temps
-#$CXXFLAGS += " -static -O0 -g -std=#{$CXX_STANDARD} "
-
-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', '')
-
-have_func("rb_array_const_ptr", "ruby.h")
-have_macro("FIX_CONST_VALUE_PTR", "ruby.h")
-have_macro("RARRAY_CONST_PTR", "ruby.h")
-have_macro("RARRAY_AREF", "ruby.h")
-
 create_conf_h("nmatrix_config.h")
 create_makefile("nmatrix")
 

data/ext/nmatrix/math.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - present, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - present, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -134,6 +134,7 @@
 #include "math/cblas_enums.h"
 
 #include "data/data.h"
+#include "math/magnitude.h"
 #include "math/imax.h"
 #include "math/scal.h"
 #include "math/laswp.h"
@@ -237,11 +238,14 @@ namespace nm {
       int col_index[M];
 
       for (int k = 0;k < M; ++k) {
-        DType akk = std::abs( matrix[k * (M + 1)] ) ; // diagonal element
+        typename MagnitudeDType<DType>::type akk;
+        akk = magnitude( matrix[k * (M + 1)] ); // diagonal element
+
         int interchange = k;
 
         for (int row = k + 1; row < M; ++row) {
-          DType big = std::abs( matrix[M*row + k] ); // element below the temp pivot
+          typename MagnitudeDType<DType>::type big;
+          big = magnitude( matrix[M*row + k] ); // element below the temp pivot
           
           if ( big > akk ) {
             interchange = row;
@@ -694,16 +698,12 @@ static VALUE nm_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx, VALUE y, VAL
 static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   static void (*ttable[nm::NUM_DTYPES])(const int N, const void* X, const int incX, void* sum) = {
-/*      nm::math::cblas_nrm2<uint8_t,uint8_t>,
-      nm::math::cblas_nrm2<int8_t,int8_t>,
-      nm::math::cblas_nrm2<int16_t,int16_t>,
-      nm::math::cblas_nrm2<int32_t,int32_t>, */
       NULL, NULL, NULL, NULL, NULL, // no help for integers
-      nm::math::cblas_nrm2<float32_t,float32_t>,
-      nm::math::cblas_nrm2<float64_t,float64_t>,
-      nm::math::cblas_nrm2<float32_t,nm::Complex64>,
-      nm::math::cblas_nrm2<float64_t,nm::Complex128>,
-      nm::math::cblas_nrm2<nm::RubyObject,nm::RubyObject>
+      nm::math::cblas_nrm2<float32_t>,
+      nm::math::cblas_nrm2<float64_t>,
+      nm::math::cblas_nrm2<nm::Complex64>,
+      nm::math::cblas_nrm2<nm::Complex128>,
+      nm::math::cblas_nrm2<nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
@@ -748,16 +748,16 @@ static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 static VALUE nm_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   static void (*ttable[nm::NUM_DTYPES])(const int N, const void* X, const int incX, void* sum) = {
-      nm::math::cblas_asum<uint8_t,uint8_t>,
-      nm::math::cblas_asum<int8_t,int8_t>,
-      nm::math::cblas_asum<int16_t,int16_t>,
-      nm::math::cblas_asum<int32_t,int32_t>,
-      nm::math::cblas_asum<int64_t,int64_t>,
-      nm::math::cblas_asum<float32_t,float32_t>,
-      nm::math::cblas_asum<float64_t,float64_t>,
-      nm::math::cblas_asum<float32_t,nm::Complex64>,
-      nm::math::cblas_asum<float64_t,nm::Complex128>,
-      nm::math::cblas_asum<nm::RubyObject,nm::RubyObject>
+      nm::math::cblas_asum<uint8_t>,
+      nm::math::cblas_asum<int8_t>,
+      nm::math::cblas_asum<int16_t>,
+      nm::math::cblas_asum<int32_t>,
+      nm::math::cblas_asum<int64_t>,
+      nm::math::cblas_asum<float32_t>,
+      nm::math::cblas_asum<float64_t>,
+      nm::math::cblas_asum<nm::Complex64>,
+      nm::math::cblas_asum<nm::Complex128>,
+      nm::math::cblas_asum<nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
@@ -998,7 +998,7 @@ static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALUE n, VAL
 
   // Allocate the C version of the pivot index array
   int* ipiv_;
-  if (TYPE(ipiv) != T_ARRAY) {
+  if (!RB_TYPE_P(ipiv, T_ARRAY)) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");
   } else {
     ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));
@@ -1050,7 +1050,7 @@ static VALUE nm_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE lda, VALUE k1,
 
   // Allocate the C version of the pivot index array
   int* ipiv_;
-  if (TYPE(ipiv) != T_ARRAY) {
+  if (!RB_TYPE_P(ipiv, T_ARRAY)) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");
   } else {
     ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));

data/ext/nmatrix/math/asum.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - present, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - present, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -60,6 +60,8 @@
 #define ASUM_H
 
 
+#include "math/magnitude.h"
+
 namespace nm { namespace math {
 
 /*
@@ -73,44 +75,21 @@ namespace nm { namespace math {
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-inline ReturnDType asum(const int N, const DType* X, const int incX) {
-  ReturnDType sum = 0;
-  if ((N > 0) && (incX > 0)) {
-    for (int i = 0; i < N; ++i) {
-      sum += std::abs(X[i*incX]);
-    }
-  }
-  return sum;
-}
-
-
-template <>
-inline float asum(const int N, const Complex64* X, const int incX) {
-  float sum = 0;
-  if ((N > 0) && (incX > 0)) {
-    for (int i = 0; i < N; ++i) {
-      sum += std::abs(X[i*incX].r) + std::abs(X[i*incX].i);
-    }
-  }
-  return sum;
-}
-
-template <>
-inline double asum(const int N, const Complex128* X, const int incX) {
-  double sum = 0;
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType asum(const int N, const DType* X, const int incX) {
+  MDType sum = 0;
   if ((N > 0) && (incX > 0)) {
     for (int i = 0; i < N; ++i) {
-      sum += std::abs(X[i*incX].r) + std::abs(X[i*incX].i);
+      sum += magnitude(X[i*incX]);
     }
   }
   return sum;
 }
 
 
-template <typename ReturnDType, typename DType>
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
 inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
-  *reinterpret_cast<ReturnDType*>( sum ) = asum<ReturnDType, DType>( N, reinterpret_cast<const DType*>(X), incX );
+  *reinterpret_cast<MDType*>( sum ) = asum<DType,MDType>( N, reinterpret_cast<const DType*>(X), incX );
 }
 
 

data/ext/nmatrix/math/cblas_templates_core.h

@@ -107,9 +107,9 @@ inline void cblas_rot(const int N, void* X, const int incX, void* Y, const int i
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-inline ReturnDType asum(const int N, const DType* X, const int incX) {
-  return nm::math::asum<ReturnDType,DType>(N,X,incX);
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType asum(const int N, const DType* X, const int incX) {
+  return nm::math::asum<DType,MDType>(N,X,incX);
 }
 
 
@@ -134,9 +134,9 @@ inline double asum(const int N, const Complex128* X, const int incX) {
 }
 
 
-template <typename ReturnDType, typename DType>
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
 inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
-  *static_cast<ReturnDType*>( sum ) = asum<ReturnDType, DType>( N, static_cast<const DType*>(X), incX );
+  *static_cast<MDType*>( sum ) = asum<DType, MDType>( N, static_cast<const DType*>(X), incX );
 }
 
 /*
@@ -149,9 +149,9 @@ inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-inline ReturnDType nrm2(const int N, const DType* X, const int incX) {
-  return nm::math::nrm2<ReturnDType,DType>(N, X, incX);
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType nrm2(const int N, const DType* X, const int incX) {
+  return nm::math::nrm2<DType,MDType>(N, X, incX);
 }
 
 
@@ -175,9 +175,9 @@ inline double nrm2(const int N, const Complex128* X, const int incX) {
   return cblas_dznrm2(N, X, incX);
 }
 
-template <typename ReturnDType, typename DType>
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
 inline void cblas_nrm2(const int N, const void* X, const int incX, void* result) {
-  *static_cast<ReturnDType*>( result ) = nrm2<ReturnDType, DType>( N, static_cast<const DType*>(X), incX );
+  *static_cast<MDType*>( result ) = nrm2<DType, MDType>( N, static_cast<const DType*>(X), incX );
 }
 
 //imax