nmatrix-gemv 0.0.3

data/ext/nmatrix_gemv/types.h

@@ -0,0 +1,54 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == types.h
+//
+// Definition of simple types used throughout NMatrix.
+
+#ifndef NMATRIX_TYPES_H
+#define NMATRIX_TYPES_H
+
+/*
+ * Standard Includes
+ */
+
+#include <cstdint>
+
+/*
+ * Macros
+ */
+
+#define EPSILON 1E-10
+#define FP_IS_ZERO(n) (-EPSILON < n && n < EPSILON)
+#define FP_EQUAL(a, b) FP_IS_ZERO((a - b))
+
+/*
+ * Types
+ */
+
+typedef float		float32_t;
+typedef double	float64_t;
+
+typedef size_t  IType;
+
+#endif

data/ext/nmatrix_gemv/util/util.h

@@ -0,0 +1,78 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == util.h
+//
+// Header file for utility functions and data.
+
+#ifndef UTIL_H
+#define UTIL_H
+
+/*
+ * Standard Includes
+ */
+
+/*
+ * Project Includes
+ */
+
+#include "types.h"
+
+/*
+ * Macros
+ */
+
+/*
+ * Types
+ */
+
+/*
+ * Data
+ */
+
+/*
+ * Functions
+ */
+namespace nm {
+  template <typename Type>
+  inline Type gcf(Type x, Type y) {
+    Type t;
+
+    if (x < 0) x = -x;
+    if (y < 0) y = -y;
+
+    if (x == 0) return y;
+    if (y == 0) return x;
+
+    while (x > 0) {
+      t = x;
+      x = y % x;
+      y = t;
+    }
+
+    return y;
+  }
+} // end of namespace nm
+
+
+#endif // UTIL_H

data/lib/nmatrix-gemv.rb

@@ -0,0 +1,43 @@
+# = 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
+#
+# == nmatrix.rb
+#
+# This file loads the C extension for NMatrix and all the ruby files.
+#
+
+# For some reason nmatrix.so ends up in a different place during gem build.
+if File.exist?("lib/nmatrixr_gemv/nmatrix_gemv.so") #|| File.exist?("lib/nmatrix/nmatrix.bundle")
+  # Development
+  require "nmatrixr_gemv/nmatrix_gemv.so"
+else
+  # Gem
+  require "nmatrix_gemv.so"
+end
+
+require 'nmatrix_gemv/nmatrix_gemv.rb'
+require 'nmatrix_gemv/blas.rb'
+# require 'nmatrix/version.rb'
+#require 'nmatrix/nvector.rb'
+# require 'nmatrix/blas.rb'
+# require 'nmatrix/monkeys'
+# require "nmatrix/shortcuts.rb"

data/lib/nmatrix_gemv/blas.rb

@@ -0,0 +1,85 @@
+#--
+# = 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
+#
+# == blas.rb
+#
+# This file contains the safer accessors for the BLAS functions
+# supported by NMatrix.
+#++
+
+module NMatrix::BLAS
+  class << self
+
+    #
+    # call-seq:
+    #     gemv(a, x) -> NMatrix
+    #     gemv(a, x, y) -> NMatrix
+    #     gemv(a, x, y, alpha, beta) -> NMatrix
+    #
+    # Implements matrix-vector product via
+    #   y = (alpha * A * x) + (beta * y)
+    # where +alpha+ and +beta+ are scalar values.
+    #
+    # * *Arguments* :
+    #   - +a+ -> Matrix A.
+    #   - +x+ -> Vector x.
+    #   - +y+ -> Vector y.
+    #   - +alpha+ -> A scalar value that multiplies A * x.
+    #   - +beta+ -> A scalar value that multiplies y.
+    #   - +transpose_a+ ->
+    #   - +m+ ->
+    #   - +n+ ->
+    #   - +lda+ ->
+    #   - +incx+ ->
+    #   - +incy+ ->
+    # * *Returns* :
+    #   -
+    # * *Raises* :
+    #   - ++ ->
+    #
+    def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0, transpose_a = false, m = nil, n = nil, lda = nil, incx = nil, incy = nil)
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and a.stype == :dense and x.stype == :dense
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
+      raise(ArgumentError, 'NMatrix dtype mismatch.')													 unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
+
+      m ||= transpose_a ? a.shape[1] : a.shape[0]
+      n ||= transpose_a ? a.shape[0] : a.shape[1]
+
+      lda		||= a.shape[1]
+      incx	||= 1
+      incy	||= 1
+
+      # NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
+      if a.dtype == :complex64 or a.dtype == :complex128
+        alpha = Complex(1.0, 0.0) if alpha == 1.0
+        beta  = Complex(0.0, 0.0) if beta  == 0.0
+      end
+
+      y ||= NMatrix.new([m, n], dtype: a.dtype)
+
+      NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
+
+      return y
+    end
+  end
+end

data/lib/nmatrix_gemv/nmatrix_gemv.rb

@@ -0,0 +1,35 @@
+#--
+# = 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
+#
+# == nmatrix.rb
+#
+# This file contains those core functionalities which can be
+# implemented efficiently (or much more easily) in Ruby (e.g.,
+# inspect, pretty_print, element-wise operations).
+
+
+# require_relative './blas.rb'
+#
+class NMatrix
+end
+

data/lib/nmatrix_gemv/rspec.rb

@@ -0,0 +1,75 @@
+# = 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
+#
+# == rspec.rb
+#
+# Monkey patches for RSpec improving its ability to work well with
+# NMatrix (particularly #be_within).
+#
+
+require 'rspec'
+
+# Amend RSpec to allow #be_within for matrices.
+module RSpec::Matchers::BuiltIn #:nodoc:
+  class BeWithin
+
+    def of(expected)
+      @expected = expected
+      @unit     = ''
+      if expected.is_a?(NMatrix)
+        @tolerance = if @delta.is_a?(NMatrix)
+                       @delta.abs
+                     elsif @delta.is_a?(Array)
+                       NMatrix.new(:dense, expected.shape, @delta, :object).abs.cast(:dtype => expected.abs_dtype)
+                     else
+                       (NMatrix.ones_like(expected) * @delta).abs
+                     end
+      else
+        @tolerance = @delta
+      end
+
+      self
+    end
+
+    def percent_of(expected)
+      @expected  = expected
+      @unit      = '%'
+      @tolerance = @expected.abs * @delta / 100.0 # <- only change is to reverse abs and @delta
+      self
+    end
+
+    def matches?(actual)
+      @actual = actual
+      raise needs_expected     unless defined? @expected
+      raise needs_subtractable unless @actual.respond_to? :-
+      res = (@actual - @expected).abs <= @tolerance
+
+      #if res.is_a?(NMatrix)
+      #  require 'pry'
+      #  binding.pry
+      #end
+
+      res.is_a?(NMatrix) ? !res.any? { |x| !x } : res
+    end
+
+  end
+end

data/nmatrix-gemv.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name = "nmatrix-gemv"
+  gem.version = '0.0.3'
+  gem.summary = "blas gemv function interface for NMatrix" 
+  gem.description = "provide gemv function to NMatrix, just require 'nmatrix-gemv' in file to use." 
+  gem.homepage = 'http://sciruby.com'
+  gem.authors = ['Terence Ng']
+  gem.email =  ['pheotiman@gmail.com']
+  gem.license = 'BSD 2-clause'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.extensions = ['ext/nmatrix_gemv/extconf.rb']
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = '>= 1.9'
+
+  gem.add_dependency 'rdoc', '>=4.0.1'
+  #gem.add_dependency 'yard'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec-longrun'
+  #gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rake-compiler', '~>0.8.1'
+end
+

data/spec/blas_spec.rb

@@ -0,0 +1,154 @@
+# = 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
+#
+# == blas_spec.rb
+#
+# Tests for properly exposed BLAS functions.
+#
+
+# Can we use require_relative here instead?
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+
+describe NMatrix::BLAS do
+  #after :each do
+  #  GC.start
+  #end
+
+=begin
+  [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+      # This is not the same as "exposes cblas trsm", which would be for a version defined in blas.rb (which
+      # would greatly simplify the calling of cblas_trsm in terms of arguments, and which would be accessible
+      # as NMatrix::BLAS::trsm)
+      it "exposes unfriendly cblas_trsm" do
+        a     = NMatrix.new(3, [4,-1.quo(2), -3.quo(4), -2, 2, -1.quo(4), -4, -2, -1.quo(2)], dtype: dtype)
+        b     = NMatrix.new([3,1], [-1, 17, -9], dtype: dtype)
+        NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nonunit, 1, 3, 1.0, a, 3, b, 3)
+
+        # These test results all come from actually running a matrix through BLAS. We use them to ensure that NMatrix's
+        # version of these functions (for rationals) give similar results.
+
+        b[0].should == -1.quo(4)
+        b[1].should == 33.quo(4)
+        b[2].should == -13
+
+        NMatrix::BLAS::cblas_trsm(:row, :right, :upper, :transpose, :unit, 1, 3, 1.0, a, 3, b, 3)
+
+        b[0].should == -15.quo(2)
+        b[1].should == 5
+        b[2].should == -13
+      end
+    end
+  end
+
+  [:rational32,:rational64,:rational128].each do |dtype|
+    context dtype do
+      it "exposes cblas rot"
+    end
+
+    context dtype do
+      it "exposes cblas rotg"
+    end
+  end
+
+  [:float32, :float64, :complex64, :complex128, :object].each do |dtype|
+    context dtype do
+
+      it "exposes cblas rot" do
+        x = NMatrix.new([5,1], [1,2,3,4,5], dtype: dtype)
+        y = NMatrix.new([5,1], [-5,-4,-3,-2,-1], dtype: dtype)
+        x, y = NMatrix::BLAS::rot(x, y, 1.quo(2), Math.sqrt(3).quo(2), -1)
+
+        x.should be_within(1e-4).of(
+                   NMatrix.new([5,1], [-0.3660254037844386, -0.7320508075688772, -1.098076211353316, -1.4641016151377544, -1.8301270189221928], dtype: dtype)
+                 )
+
+        y.should be_within(1e-4).of(
+                   NMatrix.new([5,1], [-6.830127018922193, -5.464101615137754, -4.098076211353316, -2.732050807568877, -1.3660254037844386], dtype: dtype)
+                 )
+      end
+
+    end
+  end
+
+=end
+
+  [:float32, :float64, :complex64, :complex128, :object].each do |dtype|
+    context dtype do
+
+=begin
+      it "exposes cblas rotg" do
+        pending("broken for :object") if dtype == :object
+
+        ab = NMatrix.new([2,1], [6,-8], dtype: dtype)
+        c,s = NMatrix::BLAS::rotg(ab)
+
+        if [:float32, :float64].include?(dtype)
+          ab[0].should be_within(1e-6).of(-10)
+          ab[1].should be_within(1e-6).of(-5.quo(3))
+          c.should be_within(1e-6).of(-3.quo(5))
+        else
+          pending "need correct test cases"
+          ab[0].should be_within(1e-6).of(10)
+          ab[1].should be_within(1e-6).of(5.quo(3))
+          c.should be_within(1e-6).of(3.quo(5))
+        end
+        s.should be_within(1e-6).of(4.quo(5))
+      end
+
+      # Note: this exposes gemm, not cblas_gemm (which is the unfriendly CBLAS no-error-checking version)
+      it "exposes gemm" do
+        n = NMatrix.new([4,3], [14.0,9.0,3.0, 2.0,11.0,15.0, 0.0,12.0,17.0, 5.0,2.0,3.0], dtype: dtype)
+        m = NMatrix.new([3,2], [12.0,25.0, 9.0,10.0, 8.0,5.0], dtype: dtype)
+
+        #c = NMatrix.new([4,2], dtype)
+        r = NMatrix::BLAS.gemm(n, m) #, c)
+        #c.should equal(r) # check that both are same memory address
+
+        r.should == NMatrix.new([4,2], [273,455,243,235,244,205,102,160], dtype: dtype)
+      end
+=end
+
+      it "exposes gemv" do
+        a = NMatrix.new([4,3], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0], dtype: :float64)
+        x = NMatrix.new([3,1], [2.0, 1.0, 0.0], dtype: :float64)
+
+        NMatrix::BLAS.gemv(a, x)
+      end
+
+=begin
+      it "exposes asum" do
+        x = NMatrix.new([4,1], [1,2,3,4], dtype: :float64)
+        NMatrix::BLAS.asum(x).should == 10.0
+      end
+
+
+      it "exposes nrm2" do
+        x = NMatrix.new([4,1], [2,-4,3,5], dtype: :float64)
+        NMatrix::BLAS.nrm2(x, 1, 3).should be_within(1e-10).of(5.385164807134504)
+      end
+=end
+    end
+  end
+end
+