pnmatrix 1.2.4

data/ext/nmatrix/data/meta.h

@@ -0,0 +1,64 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == meta.h
+//
+// Header file for dealing with template metaprogramming.
+
+#ifndef META_H
+# define META_H
+
+namespace nm {
+  /*
+   * Template Metaprogramming
+   */
+  template <typename T> struct ctype_to_dtype_enum {
+    static const nm::dtype_t value_type = nm::BYTE;
+  };
+  template <> struct ctype_to_dtype_enum<uint8_t> { static const nm::dtype_t value_type = nm::BYTE; };
+  template <> struct ctype_to_dtype_enum<int8_t>  { static const nm::dtype_t value_type = nm::INT8; };
+  template <> struct ctype_to_dtype_enum<int16_t> { static const nm::dtype_t value_type = nm::INT16; };
+  template <> struct ctype_to_dtype_enum<int32_t> { static const nm::dtype_t value_type = nm::INT32; };
+  template <> struct ctype_to_dtype_enum<int64_t> { static const nm::dtype_t value_type = nm::INT64; };
+  template <> struct ctype_to_dtype_enum<float>   { static const nm::dtype_t value_type = nm::FLOAT32; };
+  template <> struct ctype_to_dtype_enum<double>  { static const nm::dtype_t value_type = nm::FLOAT64; };
+  template <> struct ctype_to_dtype_enum<Complex64>   { static const nm::dtype_t value_type = nm::COMPLEX64; };
+  template <> struct ctype_to_dtype_enum<Complex128>  { static const nm::dtype_t value_type = nm::COMPLEX128; };
+  template <> struct ctype_to_dtype_enum<RubyObject>  { static const nm::dtype_t value_type = nm::RUBYOBJ; };
+
+
+  template <nm::dtype_t Enum> struct dtype_enum_T;
+  template <> struct dtype_enum_T<nm::BYTE> { typedef uint8_t type; };
+  template <> struct dtype_enum_T<nm::INT8>  { typedef int8_t type;  };
+  template <> struct dtype_enum_T<nm::INT16> { typedef int16_t type; };
+  template <> struct dtype_enum_T<nm::INT32> { typedef int32_t type; };
+  template <> struct dtype_enum_T<nm::INT64> { typedef int64_t type; };
+  template <> struct dtype_enum_T<nm::FLOAT32> { typedef float type; };
+  template <> struct dtype_enum_T<nm::FLOAT64> { typedef double type; };
+  template <> struct dtype_enum_T<nm::COMPLEX64> { typedef nm::Complex64 type; };
+  template <> struct dtype_enum_T<nm::COMPLEX128> { typedef nm::Complex128 type; };
+  template <> struct dtype_enum_T<nm::RUBYOBJ> { typedef nm::RubyObject type; };
+
+} // end namespace nm
+
+#endif

data/ext/nmatrix/data/ruby_object.h

@@ -0,0 +1,386 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == 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 RB_FLOAT_TYPE_P(val) or RB_TYPE_P(val, T_COMPLEX))
+
+/*
+ * 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))) {}
+  
+  /*
+   * 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.
+   */
+
+#define RETURN_OBJ2NUM(mac)   if (this->rval == Qtrue) return 1; else if (this->rval == Qfalse) return 0; else return mac(this->rval);
+
+  inline operator int8_t()  const { RETURN_OBJ2NUM(NUM2INT)         }
+  inline operator uint8_t() const { RETURN_OBJ2NUM(NUM2UINT)        }
+  inline operator int16_t() const { RETURN_OBJ2NUM(NUM2INT)         }
+  inline operator uint16_t() const { RETURN_OBJ2NUM(NUM2UINT)       }
+  inline operator int32_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
+  inline operator VALUE() const { return rval; }
+  //inline operator uint32_t() const { return NUM2ULONG(this->rval);      }
+  inline operator int64_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
+  //inline operator uint64_t() const { RETURN_OBJ2NUM(NUM2ULONG)      }
+  inline operator double()   const { RETURN_OBJ2NUM(NUM2DBL)        }
+  inline operator float()  const { RETURN_OBJ2NUM(NUM2DBL)          }
+
+  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) {}
+
+  /*
+   * 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-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) 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));
+}
+
+
+////////////////////////////
+// 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;
+}
+
+} // end of namespace nm
+
+namespace std {
+  inline nm::RubyObject abs(const nm::RubyObject& obj) {
+    return obj.abs();
+  }
+
+
+  inline nm::RubyObject sqrt(const nm::RubyObject& obj) {
+    VALUE cMath = rb_const_get(rb_cObject, rb_intern("Math"));
+    return nm::RubyObject(rb_funcall(cMath, rb_intern("sqrt"), 1, obj.rval));
+  }
+}
+
+#endif // RUBY_OBJECT_H

data/ext/nmatrix/extconf.rb

@@ -0,0 +1,70 @@
+# = 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
+#
+# == extconf.rb
+#
+# This file checks for ATLAS and other necessary headers, and
+# generates a Makefile for compiling NMatrix.
+
+require File.expand_path("../../../lib/nmatrix/mkmf", __FILE__)
+
+$INSTALLFILES = [
+  ['nmatrix.h'       , '$(archdir)'], 
+  ['nmatrix.hpp'     , '$(archdir)'],
+  ['nmatrix_config.h', '$(archdir)'], 
+  ['nm_memory.h'     , '$(archdir)'],
+  ['ruby_constants.h', '$(archdir)']
+]
+
+if /cygwin|mingw/ =~ RUBY_PLATFORM
+  $INSTALLFILES << ['libnmatrix.a', '$(archdir)']
+end
+
+$DEBUG = true
+$CFLAGS = ["-Wall -Werror=return-type",$CFLAGS].join(" ")
+$CXXFLAGS = ["-Wall -Werror=return-type",$CXXFLAGS].join(" ")
+$CPPFLAGS = ["-Wall -Werror=return-type",$CPPFLAGS].join(" ")
+
+# When adding objects here, make sure their directories are included in CLEANOBJS down at the bottom of extconf.rb.
+basenames = %w{nmatrix ruby_constants data/data util/io math util/sl_list storage/common storage/storage storage/dense/dense storage/yale/yale storage/list/list}
+$objs = basenames.map { |b| "#{b}.o"   }
+$srcs = basenames.map { |b| "#{b}.cpp" }
+
+#$libs += " -lprofiler "
+
+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")
+Dir.chdir("storage") do
+  Dir.mkdir("yale")  unless Dir.exists?("yale")
+  Dir.mkdir("list")  unless Dir.exists?("list")
+  Dir.mkdir("dense") unless Dir.exists?("dense")
+end
+
+# to clean up object files in subdirectories:
+open('Makefile', 'a') do |f|
+  clean_objs_paths = %w{data storage storage/dense storage/yale storage/list util}.map { |d| "#{d}/*.#{CONFIG["OBJEXT"]}" }
+  f.write("CLEANOBJS := $(CLEANOBJS) #{clean_objs_paths.join(' ')}")
+end

data/ext/nmatrix/math/asum.h

@@ -0,0 +1,99 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 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.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == asum.h
+//
+// CBLAS asum function
+//
+
+/*
+ *             Automatically Tuned Linear Algebra Software v3.8.4
+ *                    (C) Copyright 1999 R. Clint Whaley
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. The name of the ATLAS group or the names of its contributers may
+ *      not be used to endorse or promote products derived from this
+ *      software without specific 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 ATLAS GROUP OR ITS 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.
+ *
+ */
+
+#ifndef ASUM_H
+#define ASUM_H
+
+
+#include "math/magnitude.h"
+
+namespace nm { namespace math {
+
+/*
+ * Level 1 BLAS routine which sums the absolute values of a vector's contents. If the vector consists of complex values,
+ * the routine sums the absolute values of the real and imaginary components as well.
+ *
+ * So, based on input types, these are the valid return types:
+ *    int -> int
+ *    float -> float or double
+ *    double -> double
+ *    complex64 -> float or double
+ *    complex128 -> double
+ */
+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 += magnitude(X[i*incX]);
+    }
+  }
+  return sum;
+}
+
+
+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<MDType*>( sum ) = asum<DType,MDType>( N, reinterpret_cast<const DType*>(X), incX );
+}
+
+
+
+}} // end of namespace nm::math
+
+#endif // ASUM_H

data/ext/nmatrix/math/cblas_enums.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - 2015, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2015, 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
+//
+// == cblas_enums.h
+//
+// CBLAS definitions for when CBLAS is not available.
+//
+
+#ifndef CBLAS_ENUM_DEFINED_H
+#define CBLAS_ENUM_DEFINED_H
+enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102};
+enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113};
+enum CBLAS_UPLO {CblasUpper=121, CblasLower=122};
+enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132};
+enum CBLAS_SIDE {CblasLeft=141, CblasRight=142};
+#endif