liblinear-ruby-swig 0.2.0

data/AUTHORS

@@ -0,0 +1,2 @@
+Tom Zeng <tom.z.zeng@gmail.com> (Ruby SWIG interface to LIBLINEAR)
+Chih-Jen Lin <cjlin@csie.ntu.edu.tw> and Machine Learning Group at National Taiwan University (developers of LIBLINEAR)

data/COPYING

@@ -0,0 +1,24 @@
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Tom Zeng
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/History.txt

@@ -0,0 +1,5 @@
+2009-05-10  Tom Zeng (tom.z.zeng@gmail.com)
+  * initial check-in into github
+
+2009-07-10  Tom Zeng (tom.z.zeng@gmail.com)
+  * incorporated the _convert_to_feature_node_array fix from the LIBSVM development group

data/Manifest.txt

@@ -0,0 +1,20 @@
+History.txt
+COPYING
+AUTHORS
+Manifest.txt
+README.rdoc
+Rakefile
+lib/linear.rb
+lib/linear_cv.rb
+ext/liblinear_wrap.cxx
+ext/linear.cpp
+ext/linear.h
+ext/tron.h
+ext/tron.cpp
+ext/extconf.rb
+ext/blas.h
+ext/blasp.h
+ext/daxpy.c
+ext/ddot.c
+ext/dnrm2.c
+ext/dscal.c 

data/README.rdoc

@@ -0,0 +1,79 @@
+= liblinear-ruby-swig
+
+* Ruby interface to LIBLINEAR (using SWIG)
+* http://www.tomzconsulting.com
+* http://tweetsentiments.com
+
+== DESCRIPTION:
+
+This is the Ruby LIBLINEAR SWIG (Simplified Wrapper and Interface Generator) 
+interface. LIBLINEAR is a high performance machine learning library for large 
+scale text mining(http://www.csie.ntu.edu.tw/~cjlin/liblinear).
+
+A slightly modified version of LIBLINEAR 1.51 is included which allows turning
+on/off the default debuging/logging messages. You don't need your own copy of 
+SWIG to use this library - all needed files are generated using SWIG already.
+
+The Ruby LIBLINEAR interface was used to build a decent sized text classification
+model(with 10 classes and 10000 features) using 100,000 text records (through 
+ActiveRecord in a Rails app) as training data, the recall rate is 99% and
+predication rate is around 90% on 2000 test records. The same model was tried
+with arbitrary and web page texts with pretty good results.
+
+LIBLINEAR is in use at http://tweetsentiments.com - A Twitter / Tweet sentiment
+analysis application
+
+== INSTALL:
+
+Currently the gem is available on linux only(tested on Ubuntu 8-9 and Fedora 9-12,
+and should work on OS X), and you will need g++ installed to compile the native 
+code. 
+
+    sudo gem sources -a http://gems.github.com   (you only have to do this once)
+    sudo gem install tomz-liblinear-ruby-swig
+
+== SYNOPSIS:
+
+Try the following multiclass problem in irb:
+
+    irb(main):001:0> require 'rubygems'
+    irb(main):002:0> require 'linear'
+    irb(main):003:0> pa = LParameter.new
+    irb(main):004:0> pa.solver_type = L2LOSS_SVM_DUAL
+    irb(main):005:0> pa.eps = 0.1
+    irb(main):006:0> bias = 1
+    irb(main):007:0> labels = [1, 2, 1, 2, 3]
+    irb(main):008:0> samples = [
+    irb(main):009:1*            {1=>0,2=>0.1,3=>0.2,4=>0,5=>0},
+    irb(main):010:1*            {1=>0,2=>0.1,3=>0.3,4=>-1.2,5=>0},
+    irb(main):011:1*            {1=>0.4,2=>0,3=>0,4=>0,5=>0},
+    irb(main):012:1*            {1=>0,2=>0.1,3=>0,4=>1.4,5=>0.5},
+    irb(main):013:1*            {1=>-0.1,2=>-0.2,3=>0.1,4=>1.1,5=>0.1}
+    irb(main):014:1>           ]
+    irb(main):015:0> pa.solver_type = MCSVM_CS
+    irb(main):016:0> sp = LProblem.new(labels,samples,bias)
+    irb(main):017:0> m = LModel.new(sp, pa)
+    irb(main):018:0>  pred = m.predict({1=>1,2=>0.1,3=>0.2,4=>0,5=>0})
+    => 1
+    irb(main):019:0>  pred = m.predict({1=>0,2=>0.1,3=>0.2,4=>0,5=>0})
+    => 2
+    irb(main):020:0>  pred = m.predict({1=>0,2=>0.1,3=>0.2,4=>0,5=>0})
+    => 2
+    irb(main):025:0>  pred = m.predict({1=>0.4,2=>0,3=>0,4=>0,5=>0})
+    => 1
+    irb(main):021:0>  pred = m.predict({1=>-0.1,2=>-0.2,3=>0.1,4=>1.1,5=>0.1})
+    => 3
+    irb(main):022:0> m.save("test.model")
+    irb(main):023:0> "your imagination " * 10
+
+
+For more examples see test*.rb in the liblinear-ruby-swig/liblinear-1.51/ruby
+directory
+
+== AUTHOR:
+
+Tom Zeng
+- http://twitter.com/tomzeng
+- http://www.tomzconsulting.com
+- http://www.linkedin.com/in/tomzeng
+- tom.z.zeng _at_ gmail _dot_ com

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+gem 'hoe', '>=1.8.3','<= 1.12.2'
+require 'hoe'
+
+
+task :default => ["sync_files","make_gem"] 
+
+EXT = "ext/liblinear?.#{Hoe::DLEXT}"
+
+Hoe.new('liblinear-ruby-swig', '0.2.0') do |p|
+  p.author = 'Tom Zeng'
+  p.email = 'tom.z.zeng@gmail.com'
+  p.url = 'http://www.tomzconsulting.com'
+  p.summary = 'Ruby wrapper of LIBLINEAR using SWIG'
+  p.description = 'Ruby wrapper of LIBLINEAR using SWIG'
+  
+  p.spec_extras[:extensions] = "ext/extconf.rb"
+  p.clean_globs << EXT << "ext/*.o" << "ext/Makefile"
+end
+
+task :make_gem => EXT
+
+file EXT => ["ext/extconf.rb", "ext/liblinear_wrap.cxx", "ext/linear.cpp", "ext/linear.h", "ext/tron.h", "ext/tron.cpp", "ext/blas.h", "ext/blasp.h", "ext/dscal.c", "ext/dnrm2.c", "ext/ddot.c", "ext/daxpy.c"] do
+  Dir.chdir "ext" do
+    ruby "extconf.rb"
+    sh "make"
+  end
+end
+
+task :sync_files do
+  cp "liblinear-1.51/linear.h","ext/"
+  cp "liblinear-1.51/linear.cpp","ext/"
+  cp "liblinear-1.51/tron.h","ext/"
+  cp "liblinear-1.51/tron.cpp","ext/"
+  cp "liblinear-1.51/ruby/liblinear_wrap.cxx","ext/"
+  cp "liblinear-1.51/blas/blas.h","ext/"
+  cp "liblinear-1.51/blas/blasp.h","ext/"
+  cp "liblinear-1.51/blas/dscal.c","ext/"
+  cp "liblinear-1.51/blas/dnrm2.c","ext/"
+  cp "liblinear-1.51/blas/ddot.c","ext/"
+  cp "liblinear-1.51/blas/daxpy.c","ext/"
+  cp "liblinear-1.51/ruby/linear.rb","lib/"
+  cp "liblinear-1.51/ruby/linear_cv.rb","lib/"
+end
+
+task :test do
+  puts "done"
+end

data/ext/blas.h

@@ -0,0 +1,25 @@
+/* blas.h  --  C header file for BLAS                         Ver 1.0 */
+/* Jesse Bennett                                       March 23, 2000 */
+
+/**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."
+
+	- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
+
+#ifndef BLAS_INCLUDE
+#define BLAS_INCLUDE
+
+/* Data types specific to BLAS implementation */
+typedef struct { float r, i; } fcomplex;
+typedef struct { double r, i; } dcomplex;
+typedef int blasbool;
+
+#include "blasp.h"    /* Prototypes for all BLAS functions */
+
+#define FALSE 0
+#define TRUE  1
+
+/* Macro functions */
+#define MIN(a,b) ((a) <= (b) ? (a) : (b))
+#define MAX(a,b) ((a) >= (b) ? (a) : (b))
+
+#endif

data/ext/blasp.h

@@ -0,0 +1,430 @@
+/* blasp.h  --  C prototypes for BLAS                         Ver 1.0 */
+/* Jesse Bennett                                       March 23, 2000 */
+
+/* Functions  listed in alphabetical order */
+
+#ifdef F2C_COMPAT
+
+void cdotc_(fcomplex *dotval, int *n, fcomplex *cx, int *incx,
+            fcomplex *cy, int *incy);
+
+void cdotu_(fcomplex *dotval, int *n, fcomplex *cx, int *incx,
+            fcomplex *cy, int *incy);
+
+double sasum_(int *n, float *sx, int *incx);
+
+double scasum_(int *n, fcomplex *cx, int *incx);
+
+double scnrm2_(int *n, fcomplex *x, int *incx);
+
+double sdot_(int *n, float *sx, int *incx, float *sy, int *incy);
+
+double snrm2_(int *n, float *x, int *incx);
+
+void zdotc_(dcomplex *dotval, int *n, dcomplex *cx, int *incx,
+            dcomplex *cy, int *incy);
+
+void zdotu_(dcomplex *dotval, int *n, dcomplex *cx, int *incx,
+            dcomplex *cy, int *incy);
+
+#else
+
+fcomplex cdotc_(int *n, fcomplex *cx, int *incx, fcomplex *cy, int *incy);
+
+fcomplex cdotu_(int *n, fcomplex *cx, int *incx, fcomplex *cy, int *incy);
+
+float sasum_(int *n, float *sx, int *incx);
+
+float scasum_(int *n, fcomplex *cx, int *incx);
+
+float scnrm2_(int *n, fcomplex *x, int *incx);
+
+float sdot_(int *n, float *sx, int *incx, float *sy, int *incy);
+
+float snrm2_(int *n, float *x, int *incx);
+
+dcomplex zdotc_(int *n, dcomplex *cx, int *incx, dcomplex *cy, int *incy);
+
+dcomplex zdotu_(int *n, dcomplex *cx, int *incx, dcomplex *cy, int *incy);
+
+#endif
+
+/* Remaining functions listed in alphabetical order */
+
+int caxpy_(int *n, fcomplex *ca, fcomplex *cx, int *incx, fcomplex *cy,
+           int *incy);
+
+int ccopy_(int *n, fcomplex *cx, int *incx, fcomplex *cy, int *incy);
+
+int cgbmv_(char *trans, int *m, int *n, int *kl, int *ku,
+           fcomplex *alpha, fcomplex *a, int *lda, fcomplex *x, int *incx,
+           fcomplex *beta, fcomplex *y, int *incy);
+
+int cgemm_(char *transa, char *transb, int *m, int *n, int *k,
+           fcomplex *alpha, fcomplex *a, int *lda, fcomplex *b, int *ldb,
+           fcomplex *beta, fcomplex *c, int *ldc);
+
+int cgemv_(char *trans, int *m, int *n, fcomplex *alpha, fcomplex *a,
+           int *lda, fcomplex *x, int *incx, fcomplex *beta, fcomplex *y,
+           int *incy);
+
+int cgerc_(int *m, int *n, fcomplex *alpha, fcomplex *x, int *incx,
+           fcomplex *y, int *incy, fcomplex *a, int *lda);
+
+int cgeru_(int *m, int *n, fcomplex *alpha, fcomplex *x, int *incx,
+           fcomplex *y, int *incy, fcomplex *a, int *lda);
+
+int chbmv_(char *uplo, int *n, int *k, fcomplex *alpha, fcomplex *a,
+           int *lda, fcomplex *x, int *incx, fcomplex *beta, fcomplex *y,
+           int *incy);
+
+int chemm_(char *side, char *uplo, int *m, int *n, fcomplex *alpha,
+           fcomplex *a, int *lda, fcomplex *b, int *ldb, fcomplex *beta,
+           fcomplex *c, int *ldc);
+
+int chemv_(char *uplo, int *n, fcomplex *alpha, fcomplex *a, int *lda,
+           fcomplex *x, int *incx, fcomplex *beta, fcomplex *y, int *incy);
+
+int cher_(char *uplo, int *n, float *alpha, fcomplex *x, int *incx,
+          fcomplex *a, int *lda);
+
+int cher2_(char *uplo, int *n, fcomplex *alpha, fcomplex *x, int *incx,
+           fcomplex *y, int *incy, fcomplex *a, int *lda);
+
+int cher2k_(char *uplo, char *trans, int *n, int *k, fcomplex *alpha,
+            fcomplex *a, int *lda, fcomplex *b, int *ldb, float *beta,
+            fcomplex *c, int *ldc);
+
+int cherk_(char *uplo, char *trans, int *n, int *k, float *alpha,
+           fcomplex *a, int *lda, float *beta, fcomplex *c, int *ldc);
+
+int chpmv_(char *uplo, int *n, fcomplex *alpha, fcomplex *ap, fcomplex *x,
+           int *incx, fcomplex *beta, fcomplex *y, int *incy);
+
+int chpr_(char *uplo, int *n, float *alpha, fcomplex *x, int *incx,
+          fcomplex *ap);
+
+int chpr2_(char *uplo, int *n, fcomplex *alpha, fcomplex *x, int *incx,
+           fcomplex *y, int *incy, fcomplex *ap);
+
+int crotg_(fcomplex *ca, fcomplex *cb, float *c, fcomplex *s);
+
+int cscal_(int *n, fcomplex *ca, fcomplex *cx, int *incx);
+
+int csscal_(int *n, float *sa, fcomplex *cx, int *incx);
+
+int cswap_(int *n, fcomplex *cx, int *incx, fcomplex *cy, int *incy);
+
+int csymm_(char *side, char *uplo, int *m, int *n, fcomplex *alpha,
+           fcomplex *a, int *lda, fcomplex *b, int *ldb, fcomplex *beta,
+           fcomplex *c, int *ldc);
+
+int csyr2k_(char *uplo, char *trans, int *n, int *k, fcomplex *alpha,
+            fcomplex *a, int *lda, fcomplex *b, int *ldb, fcomplex *beta,
+            fcomplex *c, int *ldc);
+
+int csyrk_(char *uplo, char *trans, int *n, int *k, fcomplex *alpha,
+           fcomplex *a, int *lda, fcomplex *beta, fcomplex *c, int *ldc);
+
+int ctbmv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           fcomplex *a, int *lda, fcomplex *x, int *incx);
+
+int ctbsv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           fcomplex *a, int *lda, fcomplex *x, int *incx);
+
+int ctpmv_(char *uplo, char *trans, char *diag, int *n, fcomplex *ap,
+           fcomplex *x, int *incx);
+
+int ctpsv_(char *uplo, char *trans, char *diag, int *n, fcomplex *ap,
+           fcomplex *x, int *incx);
+
+int ctrmm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, fcomplex *alpha, fcomplex *a, int *lda, fcomplex *b,
+           int *ldb);
+
+int ctrmv_(char *uplo, char *trans, char *diag, int *n, fcomplex *a,
+           int *lda, fcomplex *x, int *incx);
+
+int ctrsm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, fcomplex *alpha, fcomplex *a, int *lda, fcomplex *b,
+           int *ldb);
+
+int ctrsv_(char *uplo, char *trans, char *diag, int *n, fcomplex *a,
+           int *lda, fcomplex *x, int *incx);
+
+int daxpy_(int *n, double *sa, double *sx, int *incx, double *sy,
+           int *incy);
+
+int dcopy_(int *n, double *sx, int *incx, double *sy, int *incy);
+
+int dgbmv_(char *trans, int *m, int *n, int *kl, int *ku,
+           double *alpha, double *a, int *lda, double *x, int *incx,
+           double *beta, double *y, int *incy);
+
+int dgemm_(char *transa, char *transb, int *m, int *n, int *k,
+           double *alpha, double *a, int *lda, double *b, int *ldb,
+           double *beta, double *c, int *ldc);
+
+int dgemv_(char *trans, int *m, int *n, double *alpha, double *a,
+           int *lda, double *x, int *incx, double *beta, double *y, 
+           int *incy);
+
+int dger_(int *m, int *n, double *alpha, double *x, int *incx,
+          double *y, int *incy, double *a, int *lda);
+
+int drot_(int *n, double *sx, int *incx, double *sy, int *incy,
+          double *c, double *s);
+
+int drotg_(double *sa, double *sb, double *c, double *s);
+
+int dsbmv_(char *uplo, int *n, int *k, double *alpha, double *a,
+           int *lda, double *x, int *incx, double *beta, double *y, 
+           int *incy);
+
+int dscal_(int *n, double *sa, double *sx, int *incx);
+
+int dspmv_(char *uplo, int *n, double *alpha, double *ap, double *x,
+           int *incx, double *beta, double *y, int *incy);
+
+int dspr_(char *uplo, int *n, double *alpha, double *x, int *incx,
+          double *ap);
+
+int dspr2_(char *uplo, int *n, double *alpha, double *x, int *incx,
+           double *y, int *incy, double *ap);
+
+int dswap_(int *n, double *sx, int *incx, double *sy, int *incy);
+
+int dsymm_(char *side, char *uplo, int *m, int *n, double *alpha,
+           double *a, int *lda, double *b, int *ldb, double *beta,
+           double *c, int *ldc);
+
+int dsymv_(char *uplo, int *n, double *alpha, double *a, int *lda,
+           double *x, int *incx, double *beta, double *y, int *incy);
+
+int dsyr_(char *uplo, int *n, double *alpha, double *x, int *incx,
+          double *a, int *lda);
+
+int dsyr2_(char *uplo, int *n, double *alpha, double *x, int *incx,
+           double *y, int *incy, double *a, int *lda);
+
+int dsyr2k_(char *uplo, char *trans, int *n, int *k, double *alpha,
+            double *a, int *lda, double *b, int *ldb, double *beta,
+            double *c, int *ldc);
+
+int dsyrk_(char *uplo, char *trans, int *n, int *k, double *alpha,
+           double *a, int *lda, double *beta, double *c, int *ldc);
+
+int dtbmv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           double *a, int *lda, double *x, int *incx);
+
+int dtbsv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           double *a, int *lda, double *x, int *incx);
+
+int dtpmv_(char *uplo, char *trans, char *diag, int *n, double *ap,
+           double *x, int *incx);
+
+int dtpsv_(char *uplo, char *trans, char *diag, int *n, double *ap,
+           double *x, int *incx);
+
+int dtrmm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, double *alpha, double *a, int *lda, double *b, 
+           int *ldb);
+
+int dtrmv_(char *uplo, char *trans, char *diag, int *n, double *a,
+           int *lda, double *x, int *incx);
+
+int dtrsm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, double *alpha, double *a, int *lda, double *b, 
+           int *ldb);
+
+int dtrsv_(char *uplo, char *trans, char *diag, int *n, double *a,
+           int *lda, double *x, int *incx);
+
+
+int saxpy_(int *n, float *sa, float *sx, int *incx, float *sy, int *incy);
+
+int scopy_(int *n, float *sx, int *incx, float *sy, int *incy);
+
+int sgbmv_(char *trans, int *m, int *n, int *kl, int *ku,
+           float *alpha, float *a, int *lda, float *x, int *incx,
+           float *beta, float *y, int *incy);
+
+int sgemm_(char *transa, char *transb, int *m, int *n, int *k,
+           float *alpha, float *a, int *lda, float *b, int *ldb,
+           float *beta, float *c, int *ldc);
+
+int sgemv_(char *trans, int *m, int *n, float *alpha, float *a,
+           int *lda, float *x, int *incx, float *beta, float *y, 
+           int *incy);
+
+int sger_(int *m, int *n, float *alpha, float *x, int *incx,
+          float *y, int *incy, float *a, int *lda);
+
+int srot_(int *n, float *sx, int *incx, float *sy, int *incy,
+          float *c, float *s);
+
+int srotg_(float *sa, float *sb, float *c, float *s);
+
+int ssbmv_(char *uplo, int *n, int *k, float *alpha, float *a,
+           int *lda, float *x, int *incx, float *beta, float *y, 
+           int *incy);
+
+int sscal_(int *n, float *sa, float *sx, int *incx);
+
+int sspmv_(char *uplo, int *n, float *alpha, float *ap, float *x,
+           int *incx, float *beta, float *y, int *incy);
+
+int sspr_(char *uplo, int *n, float *alpha, float *x, int *incx,
+          float *ap);
+
+int sspr2_(char *uplo, int *n, float *alpha, float *x, int *incx,
+           float *y, int *incy, float *ap);
+
+int sswap_(int *n, float *sx, int *incx, float *sy, int *incy);
+
+int ssymm_(char *side, char *uplo, int *m, int *n, float *alpha,
+           float *a, int *lda, float *b, int *ldb, float *beta,
+           float *c, int *ldc);
+
+int ssymv_(char *uplo, int *n, float *alpha, float *a, int *lda,
+           float *x, int *incx, float *beta, float *y, int *incy);
+
+int ssyr_(char *uplo, int *n, float *alpha, float *x, int *incx,
+          float *a, int *lda);
+
+int ssyr2_(char *uplo, int *n, float *alpha, float *x, int *incx,
+           float *y, int *incy, float *a, int *lda);
+
+int ssyr2k_(char *uplo, char *trans, int *n, int *k, float *alpha,
+            float *a, int *lda, float *b, int *ldb, float *beta,
+            float *c, int *ldc);
+
+int ssyrk_(char *uplo, char *trans, int *n, int *k, float *alpha,
+           float *a, int *lda, float *beta, float *c, int *ldc);
+
+int stbmv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           float *a, int *lda, float *x, int *incx);
+
+int stbsv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           float *a, int *lda, float *x, int *incx);
+
+int stpmv_(char *uplo, char *trans, char *diag, int *n, float *ap,
+           float *x, int *incx);
+
+int stpsv_(char *uplo, char *trans, char *diag, int *n, float *ap,
+           float *x, int *incx);
+
+int strmm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, float *alpha, float *a, int *lda, float *b, 
+           int *ldb);
+
+int strmv_(char *uplo, char *trans, char *diag, int *n, float *a,
+           int *lda, float *x, int *incx);
+
+int strsm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, float *alpha, float *a, int *lda, float *b, 
+           int *ldb);
+
+int strsv_(char *uplo, char *trans, char *diag, int *n, float *a,
+           int *lda, float *x, int *incx);
+
+int zaxpy_(int *n, dcomplex *ca, dcomplex *cx, int *incx, dcomplex *cy,
+           int *incy);
+
+int zcopy_(int *n, dcomplex *cx, int *incx, dcomplex *cy, int *incy);
+
+int zdscal_(int *n, double *sa, dcomplex *cx, int *incx);
+
+int zgbmv_(char *trans, int *m, int *n, int *kl, int *ku,
+           dcomplex *alpha, dcomplex *a, int *lda, dcomplex *x, int *incx,
+           dcomplex *beta, dcomplex *y, int *incy);
+
+int zgemm_(char *transa, char *transb, int *m, int *n, int *k,
+           dcomplex *alpha, dcomplex *a, int *lda, dcomplex *b, int *ldb,
+           dcomplex *beta, dcomplex *c, int *ldc);
+
+int zgemv_(char *trans, int *m, int *n, dcomplex *alpha, dcomplex *a,
+           int *lda, dcomplex *x, int *incx, dcomplex *beta, dcomplex *y,
+           int *incy);
+
+int zgerc_(int *m, int *n, dcomplex *alpha, dcomplex *x, int *incx,
+           dcomplex *y, int *incy, dcomplex *a, int *lda);
+
+int zgeru_(int *m, int *n, dcomplex *alpha, dcomplex *x, int *incx,
+           dcomplex *y, int *incy, dcomplex *a, int *lda);
+
+int zhbmv_(char *uplo, int *n, int *k, dcomplex *alpha, dcomplex *a,
+           int *lda, dcomplex *x, int *incx, dcomplex *beta, dcomplex *y,
+           int *incy);
+
+int zhemm_(char *side, char *uplo, int *m, int *n, dcomplex *alpha,
+           dcomplex *a, int *lda, dcomplex *b, int *ldb, dcomplex *beta,
+           dcomplex *c, int *ldc);
+
+int zhemv_(char *uplo, int *n, dcomplex *alpha, dcomplex *a, int *lda,
+           dcomplex *x, int *incx, dcomplex *beta, dcomplex *y, int *incy);
+
+int zher_(char *uplo, int *n, double *alpha, dcomplex *x, int *incx,
+          dcomplex *a, int *lda);
+
+int zher2_(char *uplo, int *n, dcomplex *alpha, dcomplex *x, int *incx,
+           dcomplex *y, int *incy, dcomplex *a, int *lda);
+
+int zher2k_(char *uplo, char *trans, int *n, int *k, dcomplex *alpha,
+            dcomplex *a, int *lda, dcomplex *b, int *ldb, double *beta,
+            dcomplex *c, int *ldc);
+
+int zherk_(char *uplo, char *trans, int *n, int *k, double *alpha,
+           dcomplex *a, int *lda, double *beta, dcomplex *c, int *ldc);
+
+int zhpmv_(char *uplo, int *n, dcomplex *alpha, dcomplex *ap, dcomplex *x,
+           int *incx, dcomplex *beta, dcomplex *y, int *incy);
+
+int zhpr_(char *uplo, int *n, double *alpha, dcomplex *x, int *incx,
+          dcomplex *ap);
+
+int zhpr2_(char *uplo, int *n, dcomplex *alpha, dcomplex *x, int *incx,
+           dcomplex *y, int *incy, dcomplex *ap);
+
+int zrotg_(dcomplex *ca, dcomplex *cb, double *c, dcomplex *s);
+
+int zscal_(int *n, dcomplex *ca, dcomplex *cx, int *incx);
+
+int zswap_(int *n, dcomplex *cx, int *incx, dcomplex *cy, int *incy);
+
+int zsymm_(char *side, char *uplo, int *m, int *n, dcomplex *alpha,
+           dcomplex *a, int *lda, dcomplex *b, int *ldb, dcomplex *beta,
+           dcomplex *c, int *ldc);
+
+int zsyr2k_(char *uplo, char *trans, int *n, int *k, dcomplex *alpha,
+            dcomplex *a, int *lda, dcomplex *b, int *ldb, dcomplex *beta,
+            dcomplex *c, int *ldc);
+
+int zsyrk_(char *uplo, char *trans, int *n, int *k, dcomplex *alpha,
+           dcomplex *a, int *lda, dcomplex *beta, dcomplex *c, int *ldc);
+
+int ztbmv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           dcomplex *a, int *lda, dcomplex *x, int *incx);
+
+int ztbsv_(char *uplo, char *trans, char *diag, int *n, int *k,
+           dcomplex *a, int *lda, dcomplex *x, int *incx);
+
+int ztpmv_(char *uplo, char *trans, char *diag, int *n, dcomplex *ap,
+           dcomplex *x, int *incx);
+
+int ztpsv_(char *uplo, char *trans, char *diag, int *n, dcomplex *ap,
+           dcomplex *x, int *incx);
+
+int ztrmm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, dcomplex *alpha, dcomplex *a, int *lda, dcomplex *b,
+           int *ldb);
+
+int ztrmv_(char *uplo, char *trans, char *diag, int *n, dcomplex *a,
+           int *lda, dcomplex *x, int *incx);
+
+int ztrsm_(char *side, char *uplo, char *transa, char *diag, int *m,
+           int *n, dcomplex *alpha, dcomplex *a, int *lda, dcomplex *b,
+           int *ldb);
+
+int ztrsv_(char *uplo, char *trans, char *diag, int *n, dcomplex *a,
+           int *lda, dcomplex *x, int *incx);

data/ext/daxpy.c

@@ -0,0 +1,49 @@
+#include "blas.h"
+
+int daxpy_(int *n, double *sa, double *sx, int *incx, double *sy,
+           int *incy)
+{
+  long int i, m, ix, iy, nn, iincx, iincy;
+  register double ssa;
+
+  /* constant times a vector plus a vector.   
+     uses unrolled loop for increments equal to one.   
+     jack dongarra, linpack, 3/11/78.   
+     modified 12/3/93, array(1) declarations changed to array(*) */
+
+  /* Dereference inputs */
+  nn = *n;
+  ssa = *sa;
+  iincx = *incx;
+  iincy = *incy;
+
+  if( nn > 0 && ssa != 0.0 )
+  {
+    if (iincx == 1 && iincy == 1) /* code for both increments equal to 1 */
+    {
+      m = nn-3;
+      for (i = 0; i < m; i += 4)
+      {
+        sy[i] += ssa * sx[i];
+        sy[i+1] += ssa * sx[i+1];
+        sy[i+2] += ssa * sx[i+2];
+        sy[i+3] += ssa * sx[i+3];
+      }
+      for ( ; i < nn; ++i) /* clean-up loop */
+        sy[i] += ssa * sx[i];
+    }
+    else /* code for unequal increments or equal increments not equal to 1 */
+    {
+      ix = iincx >= 0 ? 0 : (1 - nn) * iincx;
+      iy = iincy >= 0 ? 0 : (1 - nn) * iincy;
+      for (i = 0; i < nn; i++)
+      {
+        sy[iy] += ssa * sx[ix];
+        ix += iincx;
+        iy += iincy;
+      }
+    }
+  }
+
+  return 0;
+} /* daxpy_ */