nmatrix 0.0.1 → 0.0.2

data/lib/nmatrix.rb

@@ -22,242 +22,34 @@
 #
 # == nmatrix.rb
 #
-# This file loads the C extension for NMatrix, and adds a few
-# additional pieces of functionality (e.g., inspect, pretty_print).
-# Also provided is NVector, which represents a rank-1 NMatrix in
-# vector operations.
+# This file loads the C extension for NMatrix and adds an autoload for the
+# NMatrix and NVector classes.
 
-# For some reason nmatrix.so ends up in a different place during gem build
-if File.exist? "lib/nmatrix/nmatrix.so"
-  require File.join(File.dirname(__FILE__), "nmatrix/nmatrix.so") # development
-else
-  require File.join(File.dirname(__FILE__), "nmatrix.so")         # gem
-end
-require File.join(File.dirname(__FILE__), "array.rb") # Load Array extensions
-
-
-class NMatrix
-  VERSION = '0.0.1'
-
-  #def inspect
-  #
-  #end
-
-  # TODO: Make this actually pretty.
-  def pretty_print
-    raise(NotImplementedError, "can only print rank 2 matrices") unless rank == 2
-    (0...shape[0]).each do |i|
-      arr = []
-      (0...shape[1]).each do |j|
-        arr << (self[i,j].nil? ? "nil" : self[i,j])
-      end
-      puts arr.join("  ")
-    end
-    nil
-  end
-
-
-  def inspect
-    original_inspect = super
-    original_inspect = original_inspect[0...original_inspect.size-1]
-    original_inspect + inspect_helper.join(" ") + ">"
-  end
-
-  def __yale_ary__to_s(sym)
-    ary = self.send("__yale_#{sym.to_s}__".to_sym)
-    "[" + ary.collect { |a| a.nil? ? "nil" : a }.join(',') + "]"
-  end
-
-  class << self
-
-    # Helper function for loading a file in the first sparse format given here:
-    #   http://math.nist.gov/MatrixMarket/formats.html
-    #
-    # Override type specifier (e.g., 'real') using :read_with => :to_f (or any other string-to-numeric conversion
-    # function), and with :dtype => :float32 or :dtype => :int8 to force storage in a lesser type.
-    def load_matrix_matrix_coordinate_file filename, options = {}
-      f = File.new(filename, "r")
-
-      func = options.has_key?(:read_with) ? options[:read_with] : nil
-      dtype = options.has_key?(:dtype) ? options[:dtype] : nil
-
-      line = f.gets
-      raise(IOError, "incorrect file type specifier") unless line =~ /^%%MatrixMarket\ matrix\ coordinate/
-      spec = line.split
-      case spec[3]
-        when 'real'
-          func ||= :to_f
-          dtype ||= :float64
-        when 'integer'
-          func ||= :to_i
-          dtype ||= :int64
-        when 'complex'
-          func ||= :to_complex
-          dtype ||= :complex128
-        when 'rational'
-          func = :to_rational
-          dtype ||= :rational128
-        else
-          raise ArgumentError, "Unrecognized dtype"
-      end unless !func.nil? && !dtype.nil?
-
-      line = f.gets
-      while line =~ /^%/
-        line = f.gets
-      end
-
-      rows, cols, entries = line.split.collect { |x| x.to_i }
-
-      matrix = NMatrix.new(:yale, [rows, cols], entries, dtype)
-
-      entries.times do
-        i,j,v = line.split
-        matrix[i.to_i-1,j.to_i-1] = v.send(func)
-      end
-
-      matrix
-    end
-
-
-    def cblas_gemm a, b, c=nil, alpha=1.0, beta=0.0, transpose_a=false, transpose_b=false, m=nil, n=nil, k=nil, lda=nil, ldb=nil, ldc=nil
-      raise(ArgumentError, "expected dense NMatrices as first two arguments") unless a.is_a?(NMatrix) && b.is_a?(NMatrix) && a.stype == :dense && b.stype == :dense
-      raise(ArgumentError, "expected nil or dense NMatrix as third argument") unless c.nil? || (c.is_a?(NMatrix) && c.stype == :dense)
-      raise(ArgumentError, "NMatrix dtype mismatch") unless a.dtype == b.dtype && (c.nil? ? true : a.dtype == c.dtype)
-
-      # First, set m, n, and k, which depend on whether we're taking the transpose of a and b.
-      if c.nil?
-        if transpose_a # either :transpose or :complex_conjugate
-          m ||= a.shape[1]
-          k ||= a.shape[0]
-        else # no transpose
-          m ||= a.shape[0]
-          k ||= a.shape[1]
-        end
-        n ||= transpose_b ? b.shape[0] : b.shape[1]
-        c = NMatrix.new([m, n], a.dtype)
-      else
-        m ||= c.shape[0]
-        n ||= c.shape[1]
-        k ||= transpose_a ? a.shape[0] : a.shape[1]
-      end
-
-      # I think these are independent of whether or not a transpose occurs.
-      lda ||= a.shape[1]
-      ldb ||= b.shape[1]
-      ldc ||= c.shape[1]
 
-      if a.dtype == :complex64 || a.dtype == :complex128 # NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta
-        alpha = Complex.new(1.0, 0.0) if alpha == 1.0
-        beta  = Complex.new(0.0, 0.0) if beta == 0.0
-      end
+#############
+# Autoloads #
+#############
 
-      # For argument descriptions, see: http://www.netlib.org/blas/dgemm.f
-      NMatrix.__cblas_gemm__(transpose_a, transpose_b, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
 
-      return c
-    end
+############
+# Requires #
+############
 
+# NMatrix
 
-    def cblas_gemv a, x, y=nil, alpha=1.0, beta=0.0, transpose_a=false, m=nil, n=nil, lda=nil, incx=nil, incy=nil
-      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
-
-      if a.dtype == :complex64 || a.dtype == :complex128 # NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta
-        alpha = Complex.new(1.0, 0.0) if alpha == 1.0
-        beta  = Complex.new(0.0, 0.0) if beta == 0.0
-      end
-
-      NMatrix.__cblas_gemv__(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
-
-      return y
-    end
-  end
-
-protected
-  def inspect_helper
-    ary = []
-    ary << "shape:[#{shape.join(',')}]" << "dtype:#{dtype}" << "stype:#{stype}"
-
-    if stype == :yale
-      ary << "capacity:#{capacity}" << "ija:#{__yale_ary__to_s(:ija)}" << "ia:#{__yale_ary__to_s(:ia)}" <<
-             "ja:#{__yale_ary__to_s(:ja)}" << "a:#{__yale_ary__to_s(:a)}" << "d:#{__yale_ary__to_s(:d)}" <<
-             "lu:#{__yale_ary__to_s(:lu)}" << "yale_size:#{__yale_size__}"
-    end
-
-    ary
-  end
+require 'nmatrix/nmatrix.rb'
+require 'nmatrix/version.rb'
+require 'nmatrix/nvector.rb'
+require 'nmatrix/blas.rb'
 
+# For some reason nmatrix.so ends up in a different place during gem build.
+if File.exist? 'lib/nmatrix/nmatrix.so'
+	# Development
+	require 'nmatrix/nmatrix.so'
+else
+	# Gem
+	require 'nmatrix.so'
 end
 
-
-
-# This is a specific type of NMatrix in which only one dimension is not 1. Although it is stored as a rank-2, n x 1,
-# matrix, it acts as a rank-1 vector of size n. If the @orientation flag is set to :row, it is stored as 1 x n instead
-# of n x 1.
-class NVector < NMatrix
-  def initialize length, *args
-    super :dense, [length,1], *args
-  end
-
-  # Orientation defaults to column (e.g., [3,1] is a column of length 3). It may also be row, e.g., for [1,5].
-  def orientation
-    defined?(@orientation) && !@orientation.nil? ? @orientation : :column
-  end
-
-  def transpose
-    t = super
-    t.send :eval, "@orientation = @orientation == :row ? :column : :row"
-    t
-  end
-
-  def transpose!
-    super
-    @orientation = @orientation == :row ? :column : :row
-    self
-  end
-
-  def multiply m
-    v = super(m)
-    v.send :eval, "@orientation = @orientation == :row ? :column : :row"
-    v
-  end
-
-  def multiply! m
-    super
-    @orientation = @orientation == :row ? :column : :row
-    self
-  end
-
-  def [] i
-    @orientation == :row ? super(0,i) : super(i,0)
-  end
-
-  def []= i,val
-    @orientation == :row ? super(0,i,val) : super(i,0,val)
-  end
-
-  def rank; 1; end
-
-  # TODO: Make this actually pretty.
-  def pretty_print
-    dim = @orientation == :row ? 1 : 0
-    arr = []
-    (0...shape[dim]).each do |i|
-      arr << self[i]
-    end
-    puts arr.join("  ")
-    nil
-  end
-
-protected
-  def inspect_helper
-    ary = super
-    ary << "orientation:#{(@orientation || 'column').to_s}"
-    ary
-  end
-
-end
+# Monkey patches.
+require 'nmatrix/monkeys'

data/nmatrix.gemspec

@@ -0,0 +1,59 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'nmatrix/version'
+
+Gem::Specification.new do |gem|
+  gem.name = "nmatrix"
+  gem.version = NMatrix::VERSION
+  gem.summary = "NMatrix is an experimental linear algebra library for Ruby, written mostly in C." 
+  gem.description = "NMatrix is an experimental linear algebra library for Ruby, written mostly in C." 
+  gem.homepage = 'http://sciruby.com'
+  gem.authors = ['John Woods', 'Chris Wailes', 'Aleksey Timin']
+  gem.email =  ['john.o.woods@gmail.com']
+  gem.post_install_message = <<-EOF
+***********************************************************
+Welcome to SciRuby: Tools for Scientific Computing in Ruby!
+
+                     *** WARNING ***
+Please be aware that NMatrix is in ALPHA status. If you're
+thinking of using NMatrix to write mission critical code,
+such as for driving a car or flying a space shuttle, you
+may wish to choose other software (for now).
+
+NMatrix requires a C compiler, and has been tested only
+with GCC 4.6.1. We are happy to accept contributions
+which improve the portability of this project.
+
+Also required is ATLAS. Most Linux distributions and Mac
+versions include ATLAS, but you may wish to compile it
+yourself.
+
+More explicit instructions for NMatrix and SciRuby should
+be available on the SciRuby website, sciruby.com, or
+through our mailing list (which can be found on our web-
+site).
+
+Thanks for trying out NMatrix! Happy coding!
+
+***********************************************************
+EOF
+
+  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/extconf.rb']
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = '>= 1.9.2'
+
+  #gem.add_dependency 'csquare', '~>0.0.2'
+
+  gem.add_development_dependency 'rake', '~>0.9'
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rspec', '~>2.9.0'
+  gem.add_development_dependency 'pry', '~>0.9.9'
+  gem.add_development_dependency 'guard-rspec', '~>0.7.0'
+  gem.add_development_dependency 'rake-compiler', '~>0.8.1'
+end
+

data/scripts/mac-brew-gcc.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+VERSION="4.7.1"
+PREFIX="/usr/gcc-${VERSION}"
+LANGUAGES="c,c++,fortran"
+MAKE="make -j 4"
+
+brew-path() { brew info $1 | head -n3 | tail -n1 | cut -d' ' -f1; }
+
+# Prerequisites
+
+brew install gmp
+brew install mpfr
+brew install libmpc
+
+# Download & install the latest GCC
+
+mkdir -p $PREFIX
+mkdir temp-gcc
+cd temp-gcc
+wget ftp://ftp.gnu.org/gnu/gcc/gcc-$VERSION/gcc-$VERSION.tar.gz
+tar xfz gcc-$VERSION.tar.gz
+rm gcc-$VERSION.tar.gz
+cd gcc-$VERSION
+
+mkdir build
+cd build
+
+../configure \
+     --prefix=$PREFIX \
+     --with-gmp=$(brew-path gmp) \
+     --with-mpfr=$(brew-path mpfr) \
+     --with-mpc=$(brew-path libmpc) \
+     --program-suffix=-$VERSION \
+     --enable-languages=$LANGUAGES \
+     --with-system-zlib \
+     --enable-stage1-checking \
+     --enable-plugin \
+     --enable-lto \
+     --disable-multilib
+
+$MAKE bootstrap
+
+make install
+
+# Uncomment for cleanup …
+# cd ../../..
+# rm -r temp-gcc

data/spec/blas_spec.rb

@@ -0,0 +1,47 @@
+# = 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
+#
+# == 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
+  [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+      it "exposes cblas trsm, with B as a vector" do
+        a = NMatrix.new(:dense, 3, [5,4,-1,0,10,-3,0,0,1], dtype)
+        b = NVector.new(3, [0,11,3], dtype)
+        alpha = 1
+        NMatrix::BLAS::cblas_trsm(:row, :left, :upper, :no_transpose, :nonunit, b.shape[0], b.shape[1], alpha, a, 3, b, 1)
+        b[0].should == -1
+        b[1].should == 2
+        b[2].should == 3
+      end
+
+      it "exposes cblas trsm, with B as a matrix"
+    end
+  end
+end

data/spec/elementwise_spec.rb

@@ -0,0 +1,164 @@
+# = 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
+#
+# == nmatrix_spec.rb
+#
+# Element-wise operation tests.
+#
+
+# Can we use require_relative here instead?
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe NMatrix do
+
+  context "list" do
+    before :each do
+      @n = NMatrix.new(:list, 2, 0, :int64)
+      @m = NMatrix.new(:list, 2, 0, :int64)
+      @n[0,0] = 52
+      @m[0,0] = -48
+      @n[1,1] = 40
+    end
+
+    it "should perform element-wise addition" do
+      r = NMatrix.new(:dense, 2, [4, 0, 0, 40], :int64).cast(:list, :int64)
+      (@n+@m).should == r
+    end
+
+    it "should perform element-wise subtraction" do
+      r = NMatrix.new(:dense, 2, [100, 0, 0, 40], :int64).cast(:list, :int64)
+      (@n-@m).should == r
+    end
+
+    it "should perform element-wise multiplication" do
+      r = NMatrix.new(:dense, 2, [-2496, 0, 0, 0], :int64).cast(:list, :int64)
+      (@n*@m).should == r
+    end
+
+    it "should perform element-wise division" do
+      m = NMatrix.new(:list, 2, 1, :int64)
+      m[1,1] = 2
+      r = NMatrix.new(:dense, 2, [52, 0, 0, 20], :int64).cast(:list, :int64)
+      (@n/@m).should == r
+    end
+
+    it "should perform element-wise modulo"
+
+    it "equals" do
+      (@n =~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
+    end
+
+    it "is not equal to" do
+      (@n !~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [1, 0, 0, 1], :byte)
+    end
+
+    it "is less than" do
+      (@n < @m).should == NMatrix.new(:list, 2, 0, :byte)
+    end
+
+    it "is greater than" do
+      (@n > @m).should == NMatrix.new(:dense, 2, [1, 0, 0, 1], :byte).cast(:list, :byte)
+    end
+
+    it "is greater than or equal to" do
+      (@n >= @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [1, 1, 1, 1], :byte)
+    end
+
+    it "is less than or equal to" do
+      (@n <= @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
+    end
+  end
+
+  context "dense" do
+    context "elementwise arithmetic" do
+      before :each do
+        @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
+        @m = NMatrix.new(:dense, 2, [-4,-1,0,66], :int64)
+      end
+
+      it "adds" do
+        r = @n+@m
+        r.should == NMatrix.new(:dense, [2,2], [-3, 1, 3, 70], :int64)
+      end
+
+      it "subtracts" do
+        r = @n-@m
+        r.should == NMatrix.new(:dense, [2,2], [5, 3, 3, -62], :int64)
+      end
+
+      it "multiplies" do
+        r = @n*@m
+        r.should == NMatrix.new(:dense, [2,2], [-4, -2, 0, 264], :int64)
+      end
+
+      it "divides in the Ruby way" do
+        m = @m.clone
+        m[1,0] = 3
+        r = @n/m
+        r.should == NMatrix.new(:dense, [2,2], [-1, -2, 1, 0], :int64)
+      end
+
+      it "modulo" do
+        r = @n % @m
+        r.should == NMatrix.new(:dense, [2,2], [0, 1, 2, 3], :int64)
+      end
+    end
+
+    context "elementwise comparisons" do
+      before :each do
+        @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
+        @m = NMatrix.new(:dense, 2, [-4,-1,3,2], :int64)
+      end
+
+      it "equals" do
+        r = @n =~ @m
+        r.should == NMatrix.new(:dense, [2,2], [0, 0, 1, 0], :byte)
+      end
+
+      it "is not equal" do
+        r = @n !~ @m
+        r.should == NMatrix.new(:dense, [2,2], [1, 1, 0, 1], :byte)
+      end
+
+      it "is less than" do
+        r = @n < @m
+        r.should == NMatrix.new(:dense, [2,2], 0, :byte)
+      end
+
+      it "is greater than" do
+        r = @n > @m
+        r.should == NMatrix.new(:dense, [2,2], [1, 1, 0, 1], :byte)
+      end
+
+      it "is less than or equal to" do
+        r = @n <= @m
+        r.should == NMatrix.new(:dense, [2,2], [0, 0, 1, 0], :byte)
+      end
+
+      it "is greater than or equal to" do
+        n = NMatrix.new(:dense, [2,2], [ 1,  2, 2, 4], :int64)
+        r = n >= @m
+        r.should == NMatrix.new(:dense, [2,2], [1, 1, 0, 1], :byte)
+      end
+    end
+  end
+end

data/spec/io_spec.rb

@@ -0,0 +1,60 @@
+# = 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
+#
+# == io_spec.rb
+#
+# Basic tests for NMatrix::IO.
+#
+require "./lib/nmatrix"
+
+describe NMatrix::IO do
+  it "repacks a string" do
+    NMatrix::IO::Matlab.repack("hello", :miUINT8, :dtype => :byte).should == "hello"
+  end
+
+  it "creates yale from internal byte-string function" do
+    n = NMatrix.new(:yale, [4,4], :byte, "\0\1\3\3\4", "\0\1\3\0\0\0\0\0\0\0\0", "\2\3\5\4", :byte)
+    n[0,0].should == 2
+    n[1,1].should == 3
+    n[1,3].should == 5
+    n[3,0].should == 4
+    n[2,2].should == 0
+    n[3,3].should == 0
+  end
+
+  it "reads MATLAB .mat file containing a single square sparse matrix" do
+    # Note: same matrix as above
+    n = NMatrix::IO::Matlab.load_mat("spec/4x4_sparse.mat")
+    n[0,0].should == 2
+    n[1,1].should == 3
+    n[1,3].should == 5
+    n[3,0].should == 4
+    n[2,2].should == 0
+    n[3,3].should == 0
+  end
+
+  it "reads MATLAB .mat file containing a single dense matrix" do
+    n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
+    m = NMatrix.new(:dense, [4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
+    n.should == m
+  end
+end

data/spec/lapack_spec.rb

@@ -0,0 +1,52 @@
+# = 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
+#
+# == lapack_spec.rb
+#
+# Tests for properly exposed LAPACK functions.
+#
+
+# Can we use require_relative here instead?
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe NMatrix::LAPACK do
+  [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+      it "exposes clapack getrf" do
+        a = NMatrix.new(:dense, 3, [4,9,2,3,5,7,8,1,6], dtype)
+        NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3)
+        a[0,0].should == 8
+        a[0,1].should == 1
+        a[0,2].should == 6
+        a[1,0].should == 0.5
+        a[1,1].should == 8.5
+        a[1,2].should == -1
+        a[2,0].should == 0.375
+        # FIXME: these are rounded, == won't work
+        #a[2,1].should == 0.544118
+        #a[2,2].should == 5.294118
+      end
+
+      it "exposes cblas trsm, with B as a matrix"
+    end
+  end
+end