nulin 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 00adc4604c91f8ccc64370847d1aa9110f3bda41
+  data.tar.gz: ddd79723d590b56b640107af787f132b13522aeb
+SHA512:
+  metadata.gz: 4d4f3b87c551814ebadc5a8cb7e06ef273f3b84db97a45ef137278fa58f6a1c05ad8d0c95921725a61364174b78d2421ca310cf2790a2007c4ce4bd3ba97879f
+  data.tar.gz: 5a1a1470a7eada53700f84acaab0069e1fc162f506b901c6a9d735ee8f0f04ab43c0bb41f0bb1d3be2c55d6baf4f67553959c35355992454ea1c2e7e7685bfe5

data/doc/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 2013 Ippei Obayashi. All rights reserved.
+
+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.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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/doc/COPYING

@@ -0,0 +1,10 @@
+Nulin is a free software copyrighted by Ippei Obayashi <ohai@kmc.gr.jp>.
+This software is distributed under the license of 2-clause BSDL.
+You can redistribute it and/or modify it under the terms of the
+2-clause BSDL (see doc/BSDL).
+
+All files under dev/defs except [sdcz]gemm are from ruby-lapack and
+copyrighted by Seiya Nishizawa <seiya@gfd-dennou.org>. These
+files are under Ruby's license. Please see the following URL
+to see more details.
+http://ruby.gfd-dennou.org/products/ruby-lapack/index.html

data/doc/README.en

@@ -0,0 +1,31 @@
+NuLin
+
+= What is NuLin?
+NuLin is a fast linear algebra library using lapack routines 
+in cooperation with NArray.
+
+NuLin has following functionalities.
+
+* Basic linear algebra
+  * determinant
+  * Linear Least Square method
+
+* Eigen problems
+  * Computing eigenvalues and eigenvectors
+
+* Matrix decomposition
+  * (Pivoted) LU decomposition
+  * Singular value decomposition
+  * QR decomposition
+  * Cholesky decomposition
+
+= Required C libraries
+* lapack  
+* f2c.h (libf2c2-dev in debian)
+
+= Required ruby packages
+* NArray (you can install NArray from rubygems: gem install narray)
+
+= TODO
+* Schur decomposition
+* GEMM

data/doc/README.ja

@@ -0,0 +1,36 @@
+NuLin
+= このライブラリについて
+このライブラリは、NArrayを利用して高度な行列演算を行うための
+ライブラリです。以下の機能を持っています。
+
+* 基本的なもの
+  * 行列式
+  * 最小二乗法
+
+* 固有値問題
+  * 固有値と固有ベクトル
+
+* 行列の分解
+  * (Pivoted) LU分解
+  * 特異値分解
+  * QR分解
+  * コレスキー分解
+
+これらは LAPACK(および ruby-lapack)を用いて実装されています。
+
+= 依存するCライブラリ
+* lapack
+* f2c.h (debian であれば libf2c2-dev を使う)
+
+= 依存するrubyパッケージ
+* NArray (gem install narray でインストールできます)
+
+= 開発の経緯
+NArray で使える LAPACK のラッパとして、 ruby-lapack が存在しますが、
+ruby-lapack は LAPACK の薄いラッパで使い勝手は良くありません。
+ruby-lapackから使いたい部品を取ってきてこのライブラリを作成しました。
+インターフェースはScipy.linalgを手本としています。
+
+= TODO
+* Schur 分解
+* GEMM

data/ext/extconf.rb

@@ -0,0 +1,33 @@
+require 'mkmf'
+require 'rubygems'
+
+def narray_gem_dir
+  begin
+    require 'rubygems'
+  rescue LoadError
+    return
+  end
+  
+  begin
+    spec = Gem::Specification.find_by_name("narray")
+    $CPPFLAGS += " -I#{spec.full_gem_path}"
+    return
+  rescue Gem::LoadError, NoMethodError
+  end
+  
+  spec = Gem.source_index.find_name("narray")
+  if spec.any?
+    $CPPFLAGS += " -I#{spec.last.full_gem_path}"
+  end
+end
+
+sitearchdir = CONFIG["sitearchdir"]
+dir_config("narray", sitearchdir, sitearchdir)
+narray_gem_dir
+
+have_header("narray.h")
+have_header("narray_config.h")
+have_library("blas")
+have_library("lapack")
+
+create_makefile("nulin_native")

data/ext/nulin_native.c

@@ -0,0 +1,637 @@
+#include <math.h>
+#include "ruby.h"
+#include "narray.h"
+#include "f2c.h"
+#include "cblas.h"
+
+static VALUE id_real = Qnil, id_imag = Qnil;
+
+static int nulin_check_narray(VALUE a)
+{
+  if(!NA_IsNArray(a))
+    rb_raise(rb_eTypeError, "A paramter must be NArray");
+  return 0;
+}
+
+#define COMPLEX_STRUCT(x) \
+  { NUM2DBL(rb_funcall(x, id_real, 0)), NUM2DBL(rb_funcall(x, id_imag, 0)) }
+
+
+extern void dgeev_(char* jobvl,char* jobvr,integer* n,doublereal* a,integer* lda,doublereal* wr,doublereal* wi,doublereal* vl,integer* ldvl,doublereal* vr,integer* ldvr,doublereal* work,integer* lwork,integer* info);
+static VALUE nulin_dgeev(VALUE self,VALUE jobvl,VALUE jobvr,VALUE n,VALUE a,VALUE lda,VALUE wr,VALUE wi,VALUE vl,VALUE ldvl,VALUE vr,VALUE ldvr,VALUE work,VALUE lwork,VALUE info)
+{
+  char JOBVL = StringValueCStr(jobvl)[0];
+  char JOBVR = StringValueCStr(jobvr)[0];
+  integer N = NUM2INT(n);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* WR = NA_PTR_TYPE((nulin_check_narray(wr),wr), doublereal*);
+  doublereal* WI = NA_PTR_TYPE((nulin_check_narray(wi),wi), doublereal*);
+  doublereal* VL = NA_PTR_TYPE((nulin_check_narray(vl),vl), doublereal*);
+  integer LDVL = NUM2INT(ldvl);
+  doublereal* VR = NA_PTR_TYPE((nulin_check_narray(vr),vr), doublereal*);
+  integer LDVR = NUM2INT(ldvr);
+  doublereal* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublereal*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  dgeev_(&JOBVL,&JOBVR,&N,A,&LDA,WR,WI,VL,&LDVL,VR,&LDVR,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void sgeev_(char* jobvl,char* jobvr,integer* n,real* a,integer* lda,real* wr,real* wi,real* vl,integer* ldvl,real* vr,integer* ldvr,real* work,integer* lwork,integer* info);
+static VALUE nulin_sgeev(VALUE self,VALUE jobvl,VALUE jobvr,VALUE n,VALUE a,VALUE lda,VALUE wr,VALUE wi,VALUE vl,VALUE ldvl,VALUE vr,VALUE ldvr,VALUE work,VALUE lwork,VALUE info)
+{
+  char JOBVL = StringValueCStr(jobvl)[0];
+  char JOBVR = StringValueCStr(jobvr)[0];
+  integer N = NUM2INT(n);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* WR = NA_PTR_TYPE((nulin_check_narray(wr),wr), real*);
+  real* WI = NA_PTR_TYPE((nulin_check_narray(wi),wi), real*);
+  real* VL = NA_PTR_TYPE((nulin_check_narray(vl),vl), real*);
+  integer LDVL = NUM2INT(ldvl);
+  real* VR = NA_PTR_TYPE((nulin_check_narray(vr),vr), real*);
+  integer LDVR = NUM2INT(ldvr);
+  real* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), real*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  sgeev_(&JOBVL,&JOBVR,&N,A,&LDA,WR,WI,VL,&LDVL,VR,&LDVR,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void zgeev_(char* jobvl,char* jobvr,integer* n,doublecomplex* a,integer* lda,doublecomplex* w,doublecomplex* vl,integer* ldvl,doublecomplex* vr,integer* ldvr,doublecomplex* work,integer* lwork,doublereal* rwork,integer* info);
+static VALUE nulin_zgeev(VALUE self,VALUE jobvl,VALUE jobvr,VALUE n,VALUE a,VALUE lda,VALUE w,VALUE vl,VALUE ldvl,VALUE vr,VALUE ldvr,VALUE work,VALUE lwork,VALUE rwork,VALUE info)
+{
+  char JOBVL = StringValueCStr(jobvl)[0];
+  char JOBVR = StringValueCStr(jobvr)[0];
+  integer N = NUM2INT(n);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublecomplex* W = NA_PTR_TYPE((nulin_check_narray(w),w), doublecomplex*);
+  doublecomplex* VL = NA_PTR_TYPE((nulin_check_narray(vl),vl), doublecomplex*);
+  integer LDVL = NUM2INT(ldvl);
+  doublecomplex* VR = NA_PTR_TYPE((nulin_check_narray(vr),vr), doublecomplex*);
+  integer LDVR = NUM2INT(ldvr);
+  doublecomplex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublecomplex*);
+  integer LWORK = NUM2INT(lwork);
+  doublereal* RWORK = NA_PTR_TYPE((nulin_check_narray(rwork),rwork), doublereal*);
+  integer INFO = NUM2INT(info);
+  zgeev_(&JOBVL,&JOBVR,&N,A,&LDA,W,VL,&LDVL,VR,&LDVR,WORK,&LWORK,RWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void cgeev_(char* jobvl,char* jobvr,integer* n,complex* a,integer* lda,complex* w,complex* vl,integer* ldvl,complex* vr,integer* ldvr,complex* work,integer* lwork,real* rwork,integer* info);
+static VALUE nulin_cgeev(VALUE self,VALUE jobvl,VALUE jobvr,VALUE n,VALUE a,VALUE lda,VALUE w,VALUE vl,VALUE ldvl,VALUE vr,VALUE ldvr,VALUE work,VALUE lwork,VALUE rwork,VALUE info)
+{
+  char JOBVL = StringValueCStr(jobvl)[0];
+  char JOBVR = StringValueCStr(jobvr)[0];
+  integer N = NUM2INT(n);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  complex* W = NA_PTR_TYPE((nulin_check_narray(w),w), complex*);
+  complex* VL = NA_PTR_TYPE((nulin_check_narray(vl),vl), complex*);
+  integer LDVL = NUM2INT(ldvl);
+  complex* VR = NA_PTR_TYPE((nulin_check_narray(vr),vr), complex*);
+  integer LDVR = NUM2INT(ldvr);
+  complex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), complex*);
+  integer LWORK = NUM2INT(lwork);
+  real* RWORK = NA_PTR_TYPE((nulin_check_narray(rwork),rwork), real*);
+  integer INFO = NUM2INT(info);
+  cgeev_(&JOBVL,&JOBVR,&N,A,&LDA,W,VL,&LDVL,VR,&LDVR,WORK,&LWORK,RWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void dgesvd_(char* jobu,char* jobvt,integer* m,integer* n,doublereal* a,integer* lda,doublereal* s,doublereal* u,integer* ldu,doublereal* vt,integer* ldvt,doublereal* work,integer* lwork,integer* info);
+static VALUE nulin_dgesvd(VALUE self,VALUE jobu,VALUE jobvt,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE s,VALUE u,VALUE ldu,VALUE vt,VALUE ldvt,VALUE work,VALUE lwork,VALUE info)
+{
+  char JOBU = StringValueCStr(jobu)[0];
+  char JOBVT = StringValueCStr(jobvt)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* S = NA_PTR_TYPE((nulin_check_narray(s),s), doublereal*);
+  doublereal* U = NA_PTR_TYPE((nulin_check_narray(u),u), doublereal*);
+  integer LDU = NUM2INT(ldu);
+  doublereal* VT = NA_PTR_TYPE((nulin_check_narray(vt),vt), doublereal*);
+  integer LDVT = NUM2INT(ldvt);
+  doublereal* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublereal*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  dgesvd_(&JOBU,&JOBVT,&M,&N,A,&LDA,S,U,&LDU,VT,&LDVT,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void sgesvd_(char* jobu,char* jobvt,integer* m,integer* n,real* a,integer* lda,real* s,real* u,integer* ldu,real* vt,integer* ldvt,real* work,integer* lwork,integer* info);
+static VALUE nulin_sgesvd(VALUE self,VALUE jobu,VALUE jobvt,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE s,VALUE u,VALUE ldu,VALUE vt,VALUE ldvt,VALUE work,VALUE lwork,VALUE info)
+{
+  char JOBU = StringValueCStr(jobu)[0];
+  char JOBVT = StringValueCStr(jobvt)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* S = NA_PTR_TYPE((nulin_check_narray(s),s), real*);
+  real* U = NA_PTR_TYPE((nulin_check_narray(u),u), real*);
+  integer LDU = NUM2INT(ldu);
+  real* VT = NA_PTR_TYPE((nulin_check_narray(vt),vt), real*);
+  integer LDVT = NUM2INT(ldvt);
+  real* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), real*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  sgesvd_(&JOBU,&JOBVT,&M,&N,A,&LDA,S,U,&LDU,VT,&LDVT,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void zgesvd_(char* jobu,char* jobvt,integer* m,integer* n,doublecomplex* a,integer* lda,doublereal* s,doublecomplex* u,integer* ldu,doublecomplex* vt,integer* ldvt,doublecomplex* work,integer* lwork,doublereal* rwork,integer* info);
+static VALUE nulin_zgesvd(VALUE self,VALUE jobu,VALUE jobvt,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE s,VALUE u,VALUE ldu,VALUE vt,VALUE ldvt,VALUE work,VALUE lwork,VALUE rwork,VALUE info)
+{
+  char JOBU = StringValueCStr(jobu)[0];
+  char JOBVT = StringValueCStr(jobvt)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublereal* S = NA_PTR_TYPE((nulin_check_narray(s),s), doublereal*);
+  doublecomplex* U = NA_PTR_TYPE((nulin_check_narray(u),u), doublecomplex*);
+  integer LDU = NUM2INT(ldu);
+  doublecomplex* VT = NA_PTR_TYPE((nulin_check_narray(vt),vt), doublecomplex*);
+  integer LDVT = NUM2INT(ldvt);
+  doublecomplex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublecomplex*);
+  integer LWORK = NUM2INT(lwork);
+  doublereal* RWORK = NA_PTR_TYPE((nulin_check_narray(rwork),rwork), doublereal*);
+  integer INFO = NUM2INT(info);
+  zgesvd_(&JOBU,&JOBVT,&M,&N,A,&LDA,S,U,&LDU,VT,&LDVT,WORK,&LWORK,RWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void cgesvd_(char* jobu,char* jobvt,integer* m,integer* n,complex* a,integer* lda,real* s,complex* u,integer* ldu,complex* vt,integer* ldvt,complex* work,integer* lwork,real* rwork,integer* info);
+static VALUE nulin_cgesvd(VALUE self,VALUE jobu,VALUE jobvt,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE s,VALUE u,VALUE ldu,VALUE vt,VALUE ldvt,VALUE work,VALUE lwork,VALUE rwork,VALUE info)
+{
+  char JOBU = StringValueCStr(jobu)[0];
+  char JOBVT = StringValueCStr(jobvt)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  real* S = NA_PTR_TYPE((nulin_check_narray(s),s), real*);
+  complex* U = NA_PTR_TYPE((nulin_check_narray(u),u), complex*);
+  integer LDU = NUM2INT(ldu);
+  complex* VT = NA_PTR_TYPE((nulin_check_narray(vt),vt), complex*);
+  integer LDVT = NUM2INT(ldvt);
+  complex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), complex*);
+  integer LWORK = NUM2INT(lwork);
+  real* RWORK = NA_PTR_TYPE((nulin_check_narray(rwork),rwork), real*);
+  integer INFO = NUM2INT(info);
+  cgesvd_(&JOBU,&JOBVT,&M,&N,A,&LDA,S,U,&LDU,VT,&LDVT,WORK,&LWORK,RWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void dgelqf_(integer* m,integer* n,doublereal* a,integer* lda,doublereal* tau,doublereal* work,integer* lwork,integer* info);
+static VALUE nulin_dgelqf(VALUE self,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), doublereal*);
+  doublereal* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublereal*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  dgelqf_(&M,&N,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void sgelqf_(integer* m,integer* n,real* a,integer* lda,real* tau,real* work,integer* lwork,integer* info);
+static VALUE nulin_sgelqf(VALUE self,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), real*);
+  real* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), real*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  sgelqf_(&M,&N,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void zgelqf_(integer* m,integer* n,doublecomplex* a,integer* lda,doublecomplex* tau,doublecomplex* work,integer* lwork,integer* info);
+static VALUE nulin_zgelqf(VALUE self,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublecomplex* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), doublecomplex*);
+  doublecomplex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublecomplex*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  zgelqf_(&M,&N,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void cgelqf_(integer* m,integer* n,complex* a,integer* lda,complex* tau,complex* work,integer* lwork,integer* info);
+static VALUE nulin_cgelqf(VALUE self,VALUE m,VALUE n,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  complex* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), complex*);
+  complex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), complex*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  cgelqf_(&M,&N,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void dorglq_(integer* m,integer* n,integer* k,doublereal* a,integer* lda,doublereal* tau,doublereal* work,integer* lwork,integer* info);
+static VALUE nulin_dorglq(VALUE self,VALUE m,VALUE n,VALUE k,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer K = NUM2INT(k);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), doublereal*);
+  doublereal* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublereal*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  dorglq_(&M,&N,&K,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void sorglq_(integer* m,integer* n,integer* k,real* a,integer* lda,real* tau,real* work,integer* lwork,integer* info);
+static VALUE nulin_sorglq(VALUE self,VALUE m,VALUE n,VALUE k,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer K = NUM2INT(k);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), real*);
+  real* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), real*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  sorglq_(&M,&N,&K,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void zunglq_(integer* m,integer* n,integer* k,doublecomplex* a,integer* lda,doublecomplex* tau,doublecomplex* work,integer* lwork,integer* info);
+static VALUE nulin_zunglq(VALUE self,VALUE m,VALUE n,VALUE k,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer K = NUM2INT(k);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublecomplex* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), doublecomplex*);
+  doublecomplex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublecomplex*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  zunglq_(&M,&N,&K,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void cunglq_(integer* m,integer* n,integer* k,complex* a,integer* lda,complex* tau,complex* work,integer* lwork,integer* info);
+static VALUE nulin_cunglq(VALUE self,VALUE m,VALUE n,VALUE k,VALUE a,VALUE lda,VALUE tau,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer K = NUM2INT(k);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  complex* TAU = NA_PTR_TYPE((nulin_check_narray(tau),tau), complex*);
+  complex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), complex*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  cunglq_(&M,&N,&K,A,&LDA,TAU,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void dgels_(char* trans,integer* m,integer* n,integer* nrhs,doublereal* a,integer* lda,doublereal* b,integer* ldb,doublereal* work,integer* lwork,integer* info);
+static VALUE nulin_dgels(VALUE self,VALUE trans,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE work,VALUE lwork,VALUE info)
+{
+  char TRANS = StringValueCStr(trans)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* B = NA_PTR_TYPE((nulin_check_narray(b),b), doublereal*);
+  integer LDB = NUM2INT(ldb);
+  doublereal* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublereal*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  dgels_(&TRANS,&M,&N,&NRHS,A,&LDA,B,&LDB,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void sgels_(char* trans,integer* m,integer* n,integer* nrhs,real* a,integer* lda,real* b,integer* ldb,real* work,integer* lwork,integer* info);
+static VALUE nulin_sgels(VALUE self,VALUE trans,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE work,VALUE lwork,VALUE info)
+{
+  char TRANS = StringValueCStr(trans)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* B = NA_PTR_TYPE((nulin_check_narray(b),b), real*);
+  integer LDB = NUM2INT(ldb);
+  real* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), real*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  sgels_(&TRANS,&M,&N,&NRHS,A,&LDA,B,&LDB,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void zgels_(char* trans,integer* m,integer* n,integer* nrhs,doublecomplex* a,integer* lda,doublecomplex* b,integer* ldb,doublecomplex* work,integer* lwork,integer* info);
+static VALUE nulin_zgels(VALUE self,VALUE trans,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE work,VALUE lwork,VALUE info)
+{
+  char TRANS = StringValueCStr(trans)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublecomplex* B = NA_PTR_TYPE((nulin_check_narray(b),b), doublecomplex*);
+  integer LDB = NUM2INT(ldb);
+  doublecomplex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublecomplex*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  zgels_(&TRANS,&M,&N,&NRHS,A,&LDA,B,&LDB,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void cgels_(char* trans,integer* m,integer* n,integer* nrhs,complex* a,integer* lda,complex* b,integer* ldb,complex* work,integer* lwork,integer* info);
+static VALUE nulin_cgels(VALUE self,VALUE trans,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE work,VALUE lwork,VALUE info)
+{
+  char TRANS = StringValueCStr(trans)[0];
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  complex* B = NA_PTR_TYPE((nulin_check_narray(b),b), complex*);
+  integer LDB = NUM2INT(ldb);
+  complex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), complex*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  cgels_(&TRANS,&M,&N,&NRHS,A,&LDA,B,&LDB,WORK,&LWORK,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void dgelss_(integer* m,integer* n,integer* nrhs,doublereal* a,integer* lda,doublereal* b,integer* ldb,doublereal* s,doublereal* rcond,integer* rank,doublereal* work,integer* lwork,integer* info);
+static VALUE nulin_dgelss(VALUE self,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE s,VALUE rcond,VALUE rank,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* B = NA_PTR_TYPE((nulin_check_narray(b),b), doublereal*);
+  integer LDB = NUM2INT(ldb);
+  doublereal* S = NA_PTR_TYPE((nulin_check_narray(s),s), doublereal*);
+  doublereal RCOND = NUM2DBL(rcond);
+  integer RANK = NUM2INT(rank);
+  doublereal* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublereal*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  dgelss_(&M,&N,&NRHS,A,&LDA,B,&LDB,S,&RCOND,&RANK,WORK,&LWORK,&INFO);
+  return rb_ary_new3(2, INT2NUM(RANK),INT2NUM(INFO));
+}
+
+extern void sgelss_(integer* m,integer* n,integer* nrhs,real* a,integer* lda,real* b,integer* ldb,real* s,real* rcond,integer* rank,real* work,integer* lwork,integer* info);
+static VALUE nulin_sgelss(VALUE self,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE s,VALUE rcond,VALUE rank,VALUE work,VALUE lwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* B = NA_PTR_TYPE((nulin_check_narray(b),b), real*);
+  integer LDB = NUM2INT(ldb);
+  real* S = NA_PTR_TYPE((nulin_check_narray(s),s), real*);
+  real RCOND = NUM2DBL(rcond);
+  integer RANK = NUM2INT(rank);
+  real* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), real*);
+  integer LWORK = NUM2INT(lwork);
+  integer INFO = NUM2INT(info);
+  sgelss_(&M,&N,&NRHS,A,&LDA,B,&LDB,S,&RCOND,&RANK,WORK,&LWORK,&INFO);
+  return rb_ary_new3(2, INT2NUM(RANK),INT2NUM(INFO));
+}
+
+extern void zgelss_(integer* m,integer* n,integer* nrhs,doublecomplex* a,integer* lda,doublecomplex* b,integer* ldb,doublereal* s,doublereal* rcond,integer* rank,doublecomplex* work,integer* lwork,doublereal* rwork,integer* info);
+static VALUE nulin_zgelss(VALUE self,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE s,VALUE rcond,VALUE rank,VALUE work,VALUE lwork,VALUE rwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublecomplex* B = NA_PTR_TYPE((nulin_check_narray(b),b), doublecomplex*);
+  integer LDB = NUM2INT(ldb);
+  doublereal* S = NA_PTR_TYPE((nulin_check_narray(s),s), doublereal*);
+  doublereal RCOND = NUM2DBL(rcond);
+  integer RANK = NUM2INT(rank);
+  doublecomplex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), doublecomplex*);
+  integer LWORK = NUM2INT(lwork);
+  doublereal* RWORK = NA_PTR_TYPE((nulin_check_narray(rwork),rwork), doublereal*);
+  integer INFO = NUM2INT(info);
+  zgelss_(&M,&N,&NRHS,A,&LDA,B,&LDB,S,&RCOND,&RANK,WORK,&LWORK,RWORK,&INFO);
+  return rb_ary_new3(2, INT2NUM(RANK),INT2NUM(INFO));
+}
+
+extern void cgelss_(integer* m,integer* n,integer* nrhs,complex* a,integer* lda,complex* b,integer* ldb,real* s,real* rcond,integer* rank,complex* work,integer* lwork,real* rwork,integer* info);
+static VALUE nulin_cgelss(VALUE self,VALUE m,VALUE n,VALUE nrhs,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE s,VALUE rcond,VALUE rank,VALUE work,VALUE lwork,VALUE rwork,VALUE info)
+{
+  integer M = NUM2INT(m);
+  integer N = NUM2INT(n);
+  integer NRHS = NUM2INT(nrhs);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  complex* B = NA_PTR_TYPE((nulin_check_narray(b),b), complex*);
+  integer LDB = NUM2INT(ldb);
+  real* S = NA_PTR_TYPE((nulin_check_narray(s),s), real*);
+  real RCOND = NUM2DBL(rcond);
+  integer RANK = NUM2INT(rank);
+  complex* WORK = NA_PTR_TYPE((nulin_check_narray(work),work), complex*);
+  integer LWORK = NUM2INT(lwork);
+  real* RWORK = NA_PTR_TYPE((nulin_check_narray(rwork),rwork), real*);
+  integer INFO = NUM2INT(info);
+  cgelss_(&M,&N,&NRHS,A,&LDA,B,&LDB,S,&RCOND,&RANK,WORK,&LWORK,RWORK,&INFO);
+  return rb_ary_new3(2, INT2NUM(RANK),INT2NUM(INFO));
+}
+
+extern void dpotrf_(char* uplo,integer* n,doublereal* a,integer* lda,integer* info);
+static VALUE nulin_dpotrf(VALUE self,VALUE uplo,VALUE n,VALUE a,VALUE lda,VALUE info)
+{
+  char UPLO = StringValueCStr(uplo)[0];
+  integer N = NUM2INT(n);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  integer INFO = NUM2INT(info);
+  dpotrf_(&UPLO,&N,A,&LDA,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void spotrf_(char* uplo,integer* n,real* a,integer* lda,integer* info);
+static VALUE nulin_spotrf(VALUE self,VALUE uplo,VALUE n,VALUE a,VALUE lda,VALUE info)
+{
+  char UPLO = StringValueCStr(uplo)[0];
+  integer N = NUM2INT(n);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  integer INFO = NUM2INT(info);
+  spotrf_(&UPLO,&N,A,&LDA,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void zpotrf_(char* uplo,integer* n,doublecomplex* a,integer* lda,integer* info);
+static VALUE nulin_zpotrf(VALUE self,VALUE uplo,VALUE n,VALUE a,VALUE lda,VALUE info)
+{
+  char UPLO = StringValueCStr(uplo)[0];
+  integer N = NUM2INT(n);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  integer INFO = NUM2INT(info);
+  zpotrf_(&UPLO,&N,A,&LDA,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void cpotrf_(char* uplo,integer* n,complex* a,integer* lda,integer* info);
+static VALUE nulin_cpotrf(VALUE self,VALUE uplo,VALUE n,VALUE a,VALUE lda,VALUE info)
+{
+  char UPLO = StringValueCStr(uplo)[0];
+  integer N = NUM2INT(n);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  integer INFO = NUM2INT(info);
+  cpotrf_(&UPLO,&N,A,&LDA,&INFO);
+  return rb_ary_new3(1, INT2NUM(INFO));
+}
+
+extern void dgemm_(char* transa,char* transb,integer* n,integer* m,integer* k,doublereal* alpha,doublereal* a,integer* lda,doublereal* b,integer* ldb,doublereal* beta,doublereal* c,integer* ldc);
+static VALUE nulin_dgemm(VALUE self,VALUE transa,VALUE transb,VALUE n,VALUE m,VALUE k,VALUE alpha,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE beta,VALUE c,VALUE ldc)
+{
+  char TRANSA = StringValueCStr(transa)[0];
+  char TRANSB = StringValueCStr(transb)[0];
+  integer N = NUM2INT(n);
+  integer M = NUM2INT(m);
+  integer K = NUM2INT(k);
+  doublereal ALPHA = NUM2DBL(alpha);
+  doublereal* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublereal*);
+  integer LDA = NUM2INT(lda);
+  doublereal* B = NA_PTR_TYPE((nulin_check_narray(b),b), doublereal*);
+  integer LDB = NUM2INT(ldb);
+  doublereal BETA = NUM2DBL(beta);
+  doublereal* C = NA_PTR_TYPE((nulin_check_narray(c),c), doublereal*);
+  integer LDC = NUM2INT(ldc);
+  dgemm_(&TRANSA,&TRANSB,&N,&M,&K,&ALPHA,A,&LDA,B,&LDB,&BETA,C,&LDC);
+  return Qnil;
+}
+
+extern void sgemm_(char* transa,char* transb,integer* n,integer* m,integer* k,real* alpha,real* a,integer* lda,real* b,integer* ldb,real* beta,real* c,integer* ldc);
+static VALUE nulin_sgemm(VALUE self,VALUE transa,VALUE transb,VALUE n,VALUE m,VALUE k,VALUE alpha,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE beta,VALUE c,VALUE ldc)
+{
+  char TRANSA = StringValueCStr(transa)[0];
+  char TRANSB = StringValueCStr(transb)[0];
+  integer N = NUM2INT(n);
+  integer M = NUM2INT(m);
+  integer K = NUM2INT(k);
+  real ALPHA = NUM2DBL(alpha);
+  real* A = NA_PTR_TYPE((nulin_check_narray(a),a), real*);
+  integer LDA = NUM2INT(lda);
+  real* B = NA_PTR_TYPE((nulin_check_narray(b),b), real*);
+  integer LDB = NUM2INT(ldb);
+  real BETA = NUM2DBL(beta);
+  real* C = NA_PTR_TYPE((nulin_check_narray(c),c), real*);
+  integer LDC = NUM2INT(ldc);
+  sgemm_(&TRANSA,&TRANSB,&N,&M,&K,&ALPHA,A,&LDA,B,&LDB,&BETA,C,&LDC);
+  return Qnil;
+}
+
+extern void zgemm_(char* transa,char* transb,integer* n,integer* m,integer* k,doublecomplex* alpha,doublecomplex* a,integer* lda,doublecomplex* b,integer* ldb,doublecomplex* beta,doublecomplex* c,integer* ldc);
+static VALUE nulin_zgemm(VALUE self,VALUE transa,VALUE transb,VALUE n,VALUE m,VALUE k,VALUE alpha,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE beta,VALUE c,VALUE ldc)
+{
+  char TRANSA = StringValueCStr(transa)[0];
+  char TRANSB = StringValueCStr(transb)[0];
+  integer N = NUM2INT(n);
+  integer M = NUM2INT(m);
+  integer K = NUM2INT(k);
+  doublecomplex ALPHA = COMPLEX_STRUCT(alpha);
+  doublecomplex* A = NA_PTR_TYPE((nulin_check_narray(a),a), doublecomplex*);
+  integer LDA = NUM2INT(lda);
+  doublecomplex* B = NA_PTR_TYPE((nulin_check_narray(b),b), doublecomplex*);
+  integer LDB = NUM2INT(ldb);
+  doublecomplex BETA = COMPLEX_STRUCT(beta);
+  doublecomplex* C = NA_PTR_TYPE((nulin_check_narray(c),c), doublecomplex*);
+  integer LDC = NUM2INT(ldc);
+  zgemm_(&TRANSA,&TRANSB,&N,&M,&K,&ALPHA,A,&LDA,B,&LDB,&BETA,C,&LDC);
+  return Qnil;
+}
+
+extern void cgemm_(char* transa,char* transb,integer* n,integer* m,integer* k,complex* alpha,complex* a,integer* lda,complex* b,integer* ldb,complex* beta,complex* c,integer* ldc);
+static VALUE nulin_cgemm(VALUE self,VALUE transa,VALUE transb,VALUE n,VALUE m,VALUE k,VALUE alpha,VALUE a,VALUE lda,VALUE b,VALUE ldb,VALUE beta,VALUE c,VALUE ldc)
+{
+  char TRANSA = StringValueCStr(transa)[0];
+  char TRANSB = StringValueCStr(transb)[0];
+  integer N = NUM2INT(n);
+  integer M = NUM2INT(m);
+  integer K = NUM2INT(k);
+  complex ALPHA = COMPLEX_STRUCT(alpha);
+  complex* A = NA_PTR_TYPE((nulin_check_narray(a),a), complex*);
+  integer LDA = NUM2INT(lda);
+  complex* B = NA_PTR_TYPE((nulin_check_narray(b),b), complex*);
+  integer LDB = NUM2INT(ldb);
+  complex BETA = COMPLEX_STRUCT(beta);
+  complex* C = NA_PTR_TYPE((nulin_check_narray(c),c), complex*);
+  integer LDC = NUM2INT(ldc);
+  cgemm_(&TRANSA,&TRANSB,&N,&M,&K,&ALPHA,A,&LDA,B,&LDB,&BETA,C,&LDC);
+  return Qnil;
+}
+
+
+void Init_nulin_native(void)
+{
+  VALUE mNuLin = rb_define_module("NuLin");
+  VALUE mNuLin_Native = rb_define_module_under(mNuLin, "Native");
+  id_real = rb_intern("real");
+  id_imag = rb_intern("imag");
+  
+  rb_define_module_function(mNuLin_Native, "dgeev", nulin_dgeev, 14);
+  rb_define_module_function(mNuLin_Native, "sgeev", nulin_sgeev, 14);
+  rb_define_module_function(mNuLin_Native, "zgeev", nulin_zgeev, 14);
+  rb_define_module_function(mNuLin_Native, "cgeev", nulin_cgeev, 14);
+  rb_define_module_function(mNuLin_Native, "dgesvd", nulin_dgesvd, 14);
+  rb_define_module_function(mNuLin_Native, "sgesvd", nulin_sgesvd, 14);
+  rb_define_module_function(mNuLin_Native, "zgesvd", nulin_zgesvd, 15);
+  rb_define_module_function(mNuLin_Native, "cgesvd", nulin_cgesvd, 15);
+  rb_define_module_function(mNuLin_Native, "dgelqf", nulin_dgelqf, 8);
+  rb_define_module_function(mNuLin_Native, "sgelqf", nulin_sgelqf, 8);
+  rb_define_module_function(mNuLin_Native, "zgelqf", nulin_zgelqf, 8);
+  rb_define_module_function(mNuLin_Native, "cgelqf", nulin_cgelqf, 8);
+  rb_define_module_function(mNuLin_Native, "dorglq", nulin_dorglq, 9);
+  rb_define_module_function(mNuLin_Native, "sorglq", nulin_sorglq, 9);
+  rb_define_module_function(mNuLin_Native, "zunglq", nulin_zunglq, 9);
+  rb_define_module_function(mNuLin_Native, "cunglq", nulin_cunglq, 9);
+  rb_define_module_function(mNuLin_Native, "dgels", nulin_dgels, 11);
+  rb_define_module_function(mNuLin_Native, "sgels", nulin_sgels, 11);
+  rb_define_module_function(mNuLin_Native, "zgels", nulin_zgels, 11);
+  rb_define_module_function(mNuLin_Native, "cgels", nulin_cgels, 11);
+  rb_define_module_function(mNuLin_Native, "dgelss", nulin_dgelss, 13);
+  rb_define_module_function(mNuLin_Native, "sgelss", nulin_sgelss, 13);
+  rb_define_module_function(mNuLin_Native, "zgelss", nulin_zgelss, 14);
+  rb_define_module_function(mNuLin_Native, "cgelss", nulin_cgelss, 14);
+  rb_define_module_function(mNuLin_Native, "dpotrf", nulin_dpotrf, 5);
+  rb_define_module_function(mNuLin_Native, "spotrf", nulin_spotrf, 5);
+  rb_define_module_function(mNuLin_Native, "zpotrf", nulin_zpotrf, 5);
+  rb_define_module_function(mNuLin_Native, "cpotrf", nulin_cpotrf, 5);
+  rb_define_module_function(mNuLin_Native, "dgemm", nulin_dgemm, 13);
+  rb_define_module_function(mNuLin_Native, "sgemm", nulin_sgemm, 13);
+  rb_define_module_function(mNuLin_Native, "zgemm", nulin_zgemm, 13);
+  rb_define_module_function(mNuLin_Native, "cgemm", nulin_cgemm, 13);
+  
+}