nmatrix 0.0.1

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/Gemfile

@@ -0,0 +1,7 @@
+# Gemfile
+
+gem "rake", "!= 0.9.0"
+
+group :development, :test do
+  gem "rspec"
+end

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.0.1 / 2012-04-10
+
+* 1 major enhancement
+
+  * Initial alpha release
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+This version of SciRuby is licensed under the BSD 2-clause license.
+
+* http://sciruby.com
+* http://github.com/sciruby/sciruby/wiki/License
+
+You *must* read the Contributor Agreement before contributing code to the SciRuby Project. This is available online:
+
+* http://github.com/sciruby/sciruby/wiki/Contributor-Agreement
+
+--
+
+Copyright (c) 2010 - 2011, Ruby Science Foundation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* 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.
+
+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 COPYRIGHT HOLDER OR 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.

data/Manifest.txt

@@ -0,0 +1,51 @@
+.autotest
+History.txt
+Manifest.txt
+README.rdoc
+LICENSE.txt
+Rakefile
+Gemfile
+spec/nmatrix_spec.rb
+spec/nmatrix_yale_spec.rb
+spec/nvector_spec.rb
+spec/syntax_tree_spec.rb
+lib/array.rb
+lib/nmatrix.rb
+lib/string.rb
+ext/nmatrix/cblas.c
+ext/nmatrix/dense.c
+ext/nmatrix/depend
+ext/nmatrix/extconf.rb
+ext/nmatrix/generator.rb
+ext/nmatrix/list.c
+ext/nmatrix/nmatrix.c
+ext/nmatrix/nmatrix.h
+ext/nmatrix/rational.c
+ext/nmatrix/yale.c
+ext/nmatrix/generator/syntax_tree.rb
+ext/nmatrix/dense/blas_header.template.c
+ext/nmatrix/dense/elementwise.template.c
+ext/nmatrix/dense/gemm.template.c
+ext/nmatrix/dense/gemv.template.c
+ext/nmatrix/dense/rationalmath.template.c
+ext/nmatrix/yale/smmp1.template.c
+ext/nmatrix/yale/smmp2.template.c
+ext/nmatrix/yale/smmp1_header.template.c
+ext/nmatrix/yale/smmp2_header.template.c
+ext/nmatrix/yale/sort_columns.template.c
+ext/nmatrix/yale/symbmm.template.c
+ext/nmatrix/yale/numbmm.template.c
+ext/nmatrix/yale/transp.template.c
+ext/nmatrix/yale/complexmath.template.c
+ext/nmatrix/yale/elementwise.template.c
+ext/nmatrix/yale/elementwise_op.template.c
+
+
+
+
+
+
+
+
+
+

data/README.rdoc

@@ -0,0 +1,63 @@
+= NMatrix
+
+http://sciruby.com
+
+* {Project homepage: sciruby.com}[http://sciruby.com]
+* {SciRuby on Google+}[https://plus.google.com/109304769076178160953/posts]
+* {Installation guide}[http://sciruby.com/docs#installation]
+
+== Description
+
+NMatrix is an experimental linear algebra library for Ruby, written mostly in C. It can be used with or without SciRuby, but is part of the SciRuby project.
+
+NMatrix was inspired by and based heavily upon {NArray}[http://narray.rubyforge.org], by Masahiro Tanaka.
+
+{<img src=https://www.pledgie.com/campaigns/15783.png?skin_name=chrome>}[http://www.pledgie.com/campaigns/15783]
+
+=== WARNING:
+
+Please be aware that SciRuby and NMatrix are in *PRE-ALPHA* status. If you're thinking of using SciRuby/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).
+
+== Features
+
+* Matrix storage containers: dense, yale, list (more to come)
+* Data types: int8, int16, int32, int64, float32, float64, complex64, complex128, rational64, rational128 (incomplete)
+* Very basic algebra (more to come)
+
+== SYNOPSIS:
+
+From the command line,
+
+    git clone git@github.com:mohawkjohn/nmatrix.git
+    cd nmatrix
+    rake console
+
+Gem coming later.
+
+== REQUIREMENTS:
+
+* ATLAS and LAPACK, probably
+* GCC 4.2
+* Ruby 1.9
+
+== INSTALLATION:
+
+See Synopsis (above) for now. Gem coming later.
+
+More detailed installation instructions are available at {here}[http://sciruby.com/docs#installation]
+
+== DEVELOPERS:
+
+Before commiting any code, you *MUST* read our {Contributor Agreement}[http://github.com/SciRuby/sciruby/wiki/Contributor-Agreement].
+
+== LICENSE:
+
+Copyright (c) 2012, The Ruby Science Foundation.
+
+All rights reserved.
+
+NMatrix, along with SciRuby, is licensed under the BSD 2-clause license. See {LICENSE.txt}[https://github.com/SciRuby/sciruby/wiki/License] for details.
+
+== DONATIONS:
+
+{<img src=https://www.pledgie.com/campaigns/15783.png?skin_name=chrome>}[http://www.pledgie.com/campaigns/15783]

data/Rakefile

@@ -0,0 +1,154 @@
+# -*- ruby -*-
+
+require 'rubygems'
+
+# Fix for problem described here: https://github.com/jbarnette/isolate/pull/39
+module Gem
+  Deprecate = Module.new do
+    include Deprecate
+  end
+end
+require 'isolate/now'
+# End Fix
+
+require 'hoe'
+require 'pathname'
+require 'rspec/core/rake_task'
+
+Hoe.plugin :compiler
+Hoe.plugin :bundler
+Hoe.plugin :git
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
+SPECDIR = BASEDIR + 'spec'
+
+VALGRIND_OPTIONS = [
+        "--num-callers=50",
+        "--error-limit=no",
+        "--partial-loads-ok=yes",
+        "--undef-value-errors=no",
+]
+VALGRIND_MEMORYFILL_OPTIONS = [
+        "--freelist-vol=100000000",
+        "--malloc-fill=6D",
+        "--free-fill=66 ",
+]
+
+GDB_OPTIONS = []
+
+
+h = Hoe.spec 'nmatrix' do
+  self.require_ruby_version ">=1.9"
+  self.developer('John Woods', 'john.o.woods@gmail.com')
+  self.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
+  #self.need_rdoc = false
+  self.readme_file = 'README.rdoc'
+  # self.rubyforge_name = 'nmatrixx' # if different than 'nmatrix'
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :console do |task|
+  cmd = [ 'irb', "-r './lib/nmatrix.rb'" ]
+  run *cmd
+end
+
+#namespace :console do
+#  CONSOLE_CMD = ['irb', "-r './lib/nmatrix.rb'"]
+#  desc "Run console under GDB."
+#  task :gdb => [ :compile ] do |task|
+#          cmd = [ 'gdb' ] + GDB_OPTIONS
+#          cmd += [ '--args' ]
+#          cmd += CONSOLE_CMD
+#          run( *cmd )
+#  end
+#
+#  desc "Run console under Valgrind."
+#  task :valgrind => [ :compile ] do |task|
+#          cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+#          cmd += CONSOLE_CMD
+#          run( *cmd )
+#  end
+#end
+
+task :default => :spec
+
+def run *cmd
+  sh(cmd.join(" "))
+end
+
+namespace :spec do
+  # partial-loads-ok and undef-value-errors necessary to ignore
+  # spurious (and eminently ignorable) warnings from the ruby
+  # interpreter
+
+  RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', SPECDIR ]
+
+  #desc "Run the spec for generator.rb"
+  #task :generator do |task|
+  #  run 'rspec spec/generator_spec.rb'
+  #end
+
+  desc "Run specs under GDB."
+  task :gdb => [ :compile ] do |task|
+          cmd = [ 'gdb' ] + GDB_OPTIONS
+          cmd += [ '--args' ]
+          cmd += RSPEC_CMD
+          run( *cmd )
+  end
+
+  desc "Run specs under Valgrind."
+  task :valgrind => [ :compile ] do |task|
+          cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+          cmd += RSPEC_CMD
+          run( *cmd )
+  end
+end
+
+
+namespace :clean do
+  task :so do |task|
+    tmp_path = "tmp/#{RUBY_PLATFORM}/nmatrix/#{RUBY_VERSION}"
+    chdir tmp_path do
+      if RUBY_PLATFORM =~ /mswin/
+        `nmake soclean`
+      else
+        mkcmd = ENV['MAKE'] || %w[gmake make].find { |c| system("#{c} -v >> /dev/null 2>&1") }
+        `#{mkcmd} soclean`
+      end
+    end
+  end
+end
+
+# vim: syntax=ruby

data/ext/nmatrix/cblas.c

@@ -0,0 +1,150 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == cblas.c
+//
+// Functions in this file allow us to call CBLAS functions using
+// arrays of function pointers, by ensuring that each has the same
+// signature.
+
+#ifndef CBLAS_C
+# define CBLAS_C
+
+#include <cblas.h>
+#include "nmatrix.h"
+
+//extern const enum CBLAS_ORDER;
+//extern const enum CBLAS_TRANSPOSE;
+
+
+inline void cblas_r32gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) r32gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.r[0], p.A, p.lda, p.B, p.ldb, p.beta.r[0], p.C, p.ldc);
+  else                        r32gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.r[0], p.B, p.ldb, p.A, p.lda, p.beta.r[0], p.C, p.ldc);
+}
+
+inline void cblas_r32gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  r32gemv(TransA, p.M, p.N, p.alpha.r[0], p.A, p.lda, p.B, p.ldb, p.beta.r[0], p.C, p.ldc);
+}
+
+inline void cblas_r64gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) r64gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.ra[0], p.A, p.lda, p.B, p.ldb, p.beta.ra[0], p.C, p.ldc);
+  else                        r64gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.ra[0], p.B, p.ldb, p.A, p.lda, p.beta.ra[0], p.C, p.ldc);
+}
+
+inline void cblas_r64gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  r64gemv(TransA, p.M, p.N, p.alpha.ra[0], p.A, p.lda, p.B, p.ldb, p.beta.ra[0], p.C, p.ldc);
+}
+
+inline void cblas_r128gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) r128gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.rat, p.A, p.lda, p.B, p.ldb, p.beta.rat, p.C, p.ldc);
+  else                        r128gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.rat, p.B, p.ldb, p.A, p.lda, p.beta.rat, p.C, p.ldc);
+}
+
+inline void cblas_r128gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  r128gemv(TransA, p.M, p.N, p.alpha.rat, p.A, p.lda, p.B, p.ldb, p.beta.rat, p.C, p.ldc);
+}
+
+inline void cblas_bgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  bgemv(TransA, p.M, p.N, p.alpha.b[0], p.A, p.lda, p.B, p.ldb, p.beta.b[0], p.C, p.ldc);
+}
+
+inline void cblas_bgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) bgemm(TransA, TransB, p.M, p.N, p.K, p.alpha.b[0], p.A, p.lda, p.B, p.ldb, p.beta.b[0], p.C, p.ldc);
+  else                        bgemm(TransB, TransA, p.N, p.M, p.K, p.alpha.b[0], p.B, p.ldb, p.A, p.lda, p.beta.b[0], p.C, p.ldc);
+}
+
+inline void cblas_i8gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  i8gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i8gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) i8gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+  else                        i8gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i16gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  i16gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i16gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) i16gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+  else                        i16gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i32gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  i32gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i32gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) i32gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+  else                        i32gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i64gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  i64gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_i64gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) i64gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
+  else                        i64gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
+}
+
+inline void cblas_vgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  if (Order == CblasColMajor) vgemm(TransA, TransB, p.M, p.N, p.K, p.alpha.v[0], p.A, p.lda, p.B, p.ldb, p.beta.v[0], p.C, p.ldc);
+  else                        vgemm(TransB, TransA, p.N, p.M, p.K, p.alpha.v[0], p.B, p.ldb, p.A, p.lda, p.beta.v[0], p.C, p.ldc);
+}
+
+inline void cblas_sgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  cblas_sgemv(Order, TransA, p.M, p.N, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
+}
+
+inline void cblas_sgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  cblas_sgemm(Order, TransA, TransB, p.M, p.N, p.K, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
+}
+
+inline void cblas_dgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  cblas_dgemv(Order, TransA, p.M, p.N, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
+}
+
+inline void cblas_dgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  cblas_dgemm(Order, TransA, TransB, p.M, p.N, p.K, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
+}
+
+inline void cblas_cgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  cblas_cgemv(Order, TransA, p.M, p.N, &(p.alpha.c), p.A, p.lda, p.B, p.ldb, &(p.beta.c), p.C, p.ldc);
+}
+
+inline void cblas_cgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  cblas_cgemm(Order, TransA, TransB, p.M, p.N, p.K, &(p.alpha.c), p.A, p.lda, p.B, p.ldb, &(p.beta.c), p.C, p.ldc);
+}
+
+inline void cblas_zgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
+  cblas_zgemv(Order, TransA, p.M, p.N, &(p.alpha.z), p.A, p.lda, p.B, p.ldb, &(p.beta.z), p.C, p.ldc);
+}
+
+inline void cblas_zgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
+  cblas_zgemm(Order, TransA, TransB, p.M, p.N, p.K, &(p.alpha.z), p.A, p.lda, p.B, p.ldb, &(p.beta.z), p.C, p.ldc);
+}
+
+
+#endif