kmat 0.0.3

data/ext/kmat/id.txt

@@ -0,0 +1,80 @@
+_define_dup_escaped_method
+_kmat_rand_b
+_kmat_rand_d
+_kmat_rand_i
+_kmat_rand_v
+_kmat_rand_z
+abs
+all_p all?
+any_p any?
+conj
+deep_freeze
+DEFAULT
+DomainError
+dup
+each
+exclude_end_p exclude_end?
+fill
+first
+imag
+inspect
+iv_kmat_stored @kmat_stored
+iv_kmat_stored_value @kmat_stored_value
+hypot
+join
+last
+near_p near?
+new
+op_comp <=>
+op_div /
+op_eq ==
+op_ge >=
+op_gt >
+op_le <=
+op_lt <
+op_minus -
+op_mul *
+op_ne !=
+op_percent %
+op_plus +
+op_pow **
+op_uminus -@
+quo
+rand
+real
+to_c
+to_s
+to_sym
+
+sin
+cos
+tan
+asin
+acos
+atan
+sinh
+cosh
+tanh
+asinh
+acosh
+atanh
+exp
+log
+sqrt
+exp2
+expm1
+log10
+log1p
+log2
+logb
+cbrt
+erf
+erfc
+lgamma
+tgamma
+ceil
+floor
+round
+trunc
+sign
+arg

data/ext/kmat/id_sym.rb

@@ -0,0 +1,40 @@
+id_list, sym_list = Hash.new, Hash.new
+[['id', id_list], ['sym', sym_list]].each do |is, list|
+	File.foreach("#{__dir__}/#{is}.txt").with_index do |line, i|
+		ary = line.chomp.split(' ')
+		case ary.size
+		when 0
+			nil
+		when 1
+			list.store(ary[0], ary[0])
+		when 2
+			list.store(ary[0], ary[1])
+		else
+			raise "Line #{i+1} in #{is}.txt cannot be recognized"
+		end
+	end
+end
+
+File.open('id_sym.c', 'w') do |f|
+	[['id', id_list, 'ID', ''], ['sym', sym_list, 'VALUE', 'rb_id2sym']].each do |is, list, iv, func|
+		list.each_key do |key|
+			f.puts "#{iv} #{is}_#{key};"
+		end
+		f.puts ''
+		f.puts "void\nkm_init_#{is}(void)\n{"
+		list.each do |key, value|
+			f.puts "\t#{is}_#{key} = #{func}(rb_intern(#{value.inspect}));"
+		end
+		f.puts '}'
+		f.puts ''
+	end
+end
+
+File.open('id_sym.h', 'w') do |f|
+	[['id', id_list, 'ID'], ['sym', sym_list, 'VALUE']].each do |is, list, iv|
+		list.each_key do |key|
+			f.puts "extern #{iv} #{is}_#{key};"
+		end
+		f.puts ''
+	end
+end

data/ext/kmat/km_util.h

@@ -0,0 +1,97 @@
+static inline size_t
+int2size_t(int i)
+{
+	return (size_t)i;
+}
+
+static inline void
+km_check_frozen(VALUE obj)
+{
+	if ( OBJ_FROZEN(obj) ) {
+		rb_raise(rb_eFrozenError, "can't modify frozen %s", rb_obj_classname(obj));
+	}
+}
+
+static inline void
+km_infect_frozen(VALUE src, VALUE dest)
+{
+	if ( OBJ_FROZEN(src) ) {
+		rb_obj_freeze(dest);
+	}
+}
+
+static inline void
+km_check_positive(int m, int n)
+{
+	if ( m < 0 || n < 0 ) {
+		rb_raise(km_eDim, "matrix size must not be negative");
+	} else if ( ((long long)m)*((long long)n) != (long long)(m*n) ) {
+		rb_raise(km_eDim, "matrix length must be within int range");
+	}
+}
+
+#define TODO rb_raise(km_eNotImp, "comming soon")
+#define TF2V(p) ( (p) ? Qtrue : Qfalse )
+#define ITSELF(x) (x)
+#define SWAP(type, a, b) do { type __temp__swap__=a; a=b; b=__temp__swap__; } while (0)
+#define SAME(a, b) ( (a) == (b) )
+#define XOR(p, q) ( ( (p)&&(!(q)) ) || ( (!(p))&&(q) ) )
+
+#define KALLOC(val, n) val = ruby_xcalloc(int2size_t(n), sizeof(*(val)))
+#define KALLOCc(work, smat) work = km_alloc_and_copy(smat)
+#define KALLOCn(work, smat) km_alloc_and_copy_if_needed(smat, &(work))
+#define KALLOCz(work, smat) km_alloc_if_needed_and_0clear(smat, &(work))
+
+#define INDEX(smat, i, j) ( (smat)->trans ? ((j)+(i)*(smat)->ld) : ((i)+(j)*(smat)->ld) )
+#define ENTITYd0(smat, id, idx) ( ((smat)->id##body)[idx] )
+#define ENTITYr0(smat, id, idx) ( *( ((smat)->id##pbody)[idx] ) )
+#define ENTITY(smat, id, i, j) ( ( (smat)->stype==ST_RSUB ) ? ENTITYr0(smat, id, INDEX(smat, i, j)) : ENTITYd0(smat, id, INDEX(smat, i, j)) )
+
+#define LENGTH(smat) ( (smat)->m*(smat)->n )
+#define LENGTHs(smat) int2size_t( (smat)->m*(smat)->n )
+#define VECTOR_P(smat) ( (smat)->m==1 || (smat)->n==1 )
+#define SAME_SIZE(sa, sb) ( ( (sa)->m==(sb)->m ) && ( (sa)->n==(sb)->n ) )
+#define CHECK_SAME_SIZE(sa, sb) do { if ( !SAME_SIZE(sa, sb) ) { rb_raise(km_eDim, "sizes must be the same, (%d, %d) != (%d, %d)", (sa)->m, (sa)->n, (sb)->m, (sb)->n); } } while (0)
+
+#define VT_SWITCH(vt_, dstate, zstate, istate, bstate, vstate) do { \
+	VTYPE __vt__ = (vt_); \
+	if ( __vt__ == VT_DOUBLE ) { dstate } \
+	else if ( __vt__ == VT_COMPLEX ) { zstate } \
+	else if ( __vt__ == VT_INT ) { istate } \
+	else if ( __vt__ == VT_BOOL ) { bstate } \
+	else if ( __vt__ == VT_VALUE ) { vstate } \
+	else { rb_raise(km_eInternal, "unknown value type"); } \
+} while (0)
+
+// definition is macro within smat/smat.c
+void km_smat_each_d(SMAT *smat, void (*func)(double *, void *), void *data);
+void km_smat_each_z(SMAT *smat, void (*func)(COMPLEX *, void *), void *data);
+void km_smat_each_i(SMAT *smat, void (*func)(int *, void *), void *data);
+void km_smat_each_b(SMAT *smat, void (*func)(bool *, void *), void *data);
+void km_smat_each_v(SMAT *smat, void (*func)(VALUE *, void *), void *data);
+void km_smat_each_with_index_d(SMAT *smat, void (*func)(double *, int, int, void *), void *data);
+void km_smat_each_with_index_z(SMAT *smat, void (*func)(COMPLEX *, int, int, void *), void *data);
+void km_smat_each_with_index_i(SMAT *smat, void (*func)(int *, int, int, void *), void *data);
+void km_smat_each_with_index_b(SMAT *smat, void (*func)(bool *, int, int, void *), void *data);
+void km_smat_each_with_index_v(SMAT *smat, void (*func)(VALUE *, int, int, void *), void *data);
+void km_smat_each2_d(SMAT *sa, SMAT *sb, void (*func)(double *, double *, void *), void *data);
+void km_smat_each2_z(SMAT *sa, SMAT *sb, void (*func)(COMPLEX *, COMPLEX *, void *), void *data);
+void km_smat_each2_i(SMAT *sa, SMAT *sb, void (*func)(int *, int *, void *), void *data);
+void km_smat_each2_b(SMAT *sa, SMAT *sb, void (*func)(bool *, bool *, void *), void *data);
+void km_smat_each2_v(SMAT *sa, SMAT *sb, void (*func)(VALUE *, VALUE *, void *), void *data);
+void km_smat_each2_dcd(SMAT *sa, const SMAT *sb, void (*func)(double *, const double *, void *), void *data);
+void km_smat_each2_zcz(SMAT *sa, const SMAT *sb, void (*func)(COMPLEX *, const COMPLEX *, void *), void *data);
+void km_smat_each2_ici(SMAT *sa, const SMAT *sb, void (*func)(int *, const int *, void *), void *data);
+void km_smat_each2_bcb(SMAT *sa, const SMAT *sb, void (*func)(bool *, const bool *, void *), void *data);
+void km_smat_each2_vcv(SMAT *sa, const SMAT *sb, void (*func)(VALUE *, const VALUE *, void *), void *data);
+void km_smat_each2_dcb(SMAT *sa, const SMAT *sb, void (*func)(double *, const bool *, void *), void *data);
+void km_smat_each2_zcb(SMAT *sa, const SMAT *sb, void (*func)(COMPLEX *, const bool *, void *), void *data);
+void km_smat_each2_icb(SMAT *sa, const SMAT *sb, void (*func)(int *, const bool *, void *), void *data);
+void km_smat_each2_vcb(SMAT *sa, const SMAT *sb, void (*func)(VALUE *, const bool *, void *), void *data);
+void km_smat_each2_dcz(SMAT *sa, const SMAT *sb, void (*func)(double *, const COMPLEX *, void *), void *data);
+void km_smat_each3_zcdcd(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(COMPLEX *, const double *, const double *, void *), void *data);
+void km_smat_each3_bcdcd(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(bool *, const double *, const double *, void *), void *data);
+void km_smat_each3_bczcz(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(bool *, const COMPLEX *, const COMPLEX *, void *), void *data);
+void km_smat_each3_bcici(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(bool *, const int *, const int *, void *), void *data);
+void km_smat_each3_bcbcb(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(bool *, const bool *, const bool *, void *), void *data);
+void km_smat_each3_bcvcv(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(bool *, const VALUE *, const VALUE *, void *), void *data);

data/ext/kmat/kmat.h

@@ -0,0 +1,96 @@
+#ifndef KMAT_H
+#define KMAT_H 1
+
+#include <stdlib.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdbool.h>
+#include <ruby.h>
+#include "lapack_headers/blas.h"
+#include "lapack_headers/lapacke.h"
+#include "lapack_headers/lapacke_utils.h"
+
+#ifndef M_PI
+  #define M_PI 3.14159265358979323846
+#endif
+#define M_2PI 6.28318530717958647692
+#define COMPLEX double _Complex
+#ifdef CMPLX /* C11 macro is available */
+#  define cpack(x,y) CMPLX(x,y)
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__INTEL_COMPILER)
+#  define cpack(x,y) __builtin_complex((double) (x), (double) (y))
+#else
+#  define cpack(x,y) ((double)(x)+I*(double)(y))
+#endif
+
+#ifndef __GNUC__
+#  define  __attribute__(x)
+#endif
+
+typedef enum {
+	VT_DOUBLE,
+	VT_COMPLEX,
+	VT_INT,
+	VT_BOOL,
+	VT_VALUE,
+	VT_END
+} VTYPE;
+typedef enum {
+	ST_FULL,
+	ST_SSUB,
+	ST_RSUB,
+	ST_END
+} STYPE;
+typedef struct {
+	union {
+		void *body;
+		double *dbody;
+		COMPLEX *zbody;
+		int *ibody;
+		bool *bbody;
+		VALUE *vbody;
+		void **pbody;
+		double **dpbody;
+		COMPLEX **zpbody;
+		int **ipbody;
+		bool **bpbody;
+		VALUE **vpbody;
+	};
+	int ld, m, n;
+	VTYPE vtype;
+	STYPE stype;
+	bool trans, may_have_sub;
+	VALUE parent;
+} SMAT;
+typedef union {
+	double d;
+	COMPLEX z;
+	int i;
+	bool b;
+	VALUE v;
+} ELEMENT;
+typedef struct {
+	union {
+		void *body;
+		double *d;
+		COMPLEX *z;
+		int *i;
+		bool *b;
+		VALUE *v;
+	};
+	int ld;
+	bool need_to_free;
+} LAWORK;
+
+#include "id_sym.h"
+#include "global_variables.h"
+extern const rb_data_type_t km_mat_data_type;
+extern VALUE kmgv_mat_random;
+
+#include "km_util.h"
+
+#include "auto_collected.h"
+#include "elementwise_function.h"
+
+#endif /* KMAT_H */

data/ext/kmat/lapack_headers/blas.h

@@ -0,0 +1,354 @@
+// The original version of this header file has been written by Azalea Clive.
+// The download link is available at <http://azalea.s35.xrea.com/blas/sample.html>.
+
+// The following modification has been made by cycloawaodorin.
+// * Use complex.h as structs for complex.
+// * Add const modifer for appropriate arguments.
+
+#include <complex.h>
+
+#ifndef BLAS_INTERFACE_HEADER
+#define BLAS_INTERFACE_HEADER
+
+#ifdef __cplusplus 
+extern "C"{
+#endif
+
+//Structs
+#undef complex
+#define complex float _Complex
+#define doublecomplex double _Complex
+
+//int xrebla_(char *srname, int *info);
+
+//Level1
+
+//AXPY
+void saxpy_(const int *n, const float         *alpha, const float         *x, const int *incx, float         *y, const int *incy);
+void daxpy_(const int *n, const double        *alpha, const double        *x, const int *incx, double        *y, const int *incy);
+void caxpy_(const int *n, const complex       *alpha, const complex       *x, const int *incx, complex       *y, const int *incy);
+void zaxpy_(const int *n, const doublecomplex *alpha, const doublecomplex *x, const int *incx, doublecomplex *y, const int *incy);
+
+//SUM
+float   sasum_(const int *n, const float         *x, const int *incx);
+float  scasum_(const int *n, const complex       *x, const int *incx);
+double  dasum_(const int *n, const double        *x, const int *incx);
+double dzasum_(const int *n, const doublecomplex *x, const int *incx);
+
+//COPY
+void scopy_(const int *n, const float         *x, const int *incx, float         *y, const int *incy);
+void dcopy_(const int *n, const double        *x, const int *incx, double        *y, const int *incy);
+void ccopy_(const int *n, const complex       *x, const int *incx, complex       *y, const int *incy);
+void zcopy_(const int *n, const doublecomplex *x, const int *incx, doublecomplex *y, const int *incy);
+
+//DOT
+float  sdot_(const int *n, const float  *x, const int *incx, const float  *y, const int *incy);
+double ddot_(const int *n, const double *x, const int *incx, const double *y, const int *incy);
+
+//DOTC
+complex       cdotc_(const int *n, const complex       *x, const int *incx, const complex       *y, const int *incy);
+doublecomplex zdotc_(const int *n, const doublecomplex *x, const int *incx, const doublecomplex *y, const int *incy);
+
+//DOTU
+complex       cdotu_(const int *n, const complex       *x, const int *incx, const complex       *y, const int *incy);
+doublecomplex zdotu_(const int *n, const doublecomplex *x, const int *incx, const doublecomplex *y, const int *incy);
+
+//NRM2
+float   snrm2_(const int *n, const float         *x, const int *incx);
+double  dnrm2_(const int *n, const double        *x, const int *incx);
+float  scnrm2_(const int *n, const complex       *x, const int *incx);
+double dznrm2_(const int *n, const doublecomplex *x, const int *incx);
+
+//ROT
+void  srot_(const int *n, float         *x, const int *incx, float         *y, const int *incy, const float  *c, const float  *s);
+void  drot_(const int *n, double        *x, const int *incx, double        *y, const int *incy, const double *c, const double *s);
+void csrot_(const int *n, complex       *x, const int *incx, complex       *y, const int *incy, const float  *c, const float  *s);
+void zdrot_(const int *n, doublecomplex *x, const int *incx, doublecomplex *y, const int *incy, const double *c, const double *s);
+
+//ROTG
+void srotg_(float         *a,float         *b, float  *c, float  *s);
+void drotg_(double        *a,double        *b, double *c, double *s);
+void crotg_(complex       *a,complex       *b, float  *c, float  *s);
+void zrotg_(doublecomplex *a,doublecomplex *b, double *c, double *s);
+
+//Stub
+//ROTMG
+//ROTM
+
+
+//SCAL
+void  sscal_(const int *n,  const float         *a, float          *x, const int *incx);
+void  dscal_(const int *n,  const double        *a, double         *x, const int *incx);
+void  cscal_(const int *n,  const complex       *a, complex        *x, const int *incx);
+void  zscal_(const int *n,  const doublecomplex *a, doublecomplex  *x, const int *incx);
+void csscal_(const int *n,  const float         *a, complex        *x, const int *incx);
+void zdscal_(const int *n,  const double        *a, doublecomplex  *x, const int *incx);
+
+//SWAP
+void sswap_(const int *n, float         *x, const int *incx, float         *y, const int *incy);
+void dswap_(const int *n, double        *x, const int *incx, double        *y, const int *incy);
+void cswap_(const int *n, complex       *x, const int *incx, complex       *y, const int *incy);
+void zswap_(const int *n, doublecomplex *x, const int *incx, doublecomplex *y, const int *incy);
+
+//IAMAX
+int isamax_(const int *n, const float         *x, const int *incx);
+int idamax_(const int *n, const double        *x, const int *incx);
+int icamax_(const int *n, const complex       *x, const int *incx);
+int izamax_(const int *n, const doublecomplex *x, const int *incx);
+
+//IAMIN
+int isamin_(const int *n, const float         *x, const int *incx);
+int idamin_(const int *n, const double        *x, const int *incx);
+int icamin_(const int *n, const complex       *x, const int *incx);
+int izamin_(const int *n, const doublecomplex *x, const int *incx);
+
+//IMAX
+int ismax_(const int *n, const float  *x, const int *incx);
+int idmax_(const int *n, const double *x, const int *incx);
+
+//IMIN
+int ismin_(const int *n, const float  *x, const int *incx);
+int idmin_(const int *n, const double *x, const int *incx);
+
+//Level2
+
+//GBMV
+void 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);
+void 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);
+void cgbmv_(char *trans, int *m, int *n, int *kl, int *ku, 
+            complex       *alpha, complex       *A, int *ldA, complex       *x, int *incx, 
+            complex       *beta , complex       *y, int *incy);
+void zgbmv_(char *trans, int *m, int *n, int *kl, int *ku, 
+            doublecomplex *alpha, doublecomplex *A, int *ldA, doublecomplex *x, int *incx, 
+            doublecomplex *beta , doublecomplex *y, int *incy);
+
+//GEMV
+void sgemv_(char *trans, int *m, int *n, 
+            float         *alpha, float         *A, int *ldA, float         *x, int *incx,
+            float         *beta , float         *y, int *incy);
+void dgemv_(char *trans, int *m, int *n, 
+            double        *alpha, double        *A, int *ldA, double        *x, int *incx, 
+            double        *beta , double        *y, int *incy);
+void cgemv_(char *trans, int *m, int *n, 
+            complex       *alpha, complex       *A, int *ldA, complex       *x, int *incx, 
+            complex       *beta , complex       *y, int *incy);
+void zgemv_(char *trans, int *m, int *n, 
+            doublecomplex *alpha, doublecomplex *A, int *ldA, doublecomplex *x, int *incx, 
+            doublecomplex *beta , doublecomplex *y, int *incy);
+
+//GER
+void sger_(int *m, int *n, float  *alpha,  float *x, int *incx,  float *y, int *incy,  float *A, int *ldA);
+void dger_(int *m, int *n, double *alpha, double *x, int *incx, double *y, int *incy, double *A, int *ldA);
+
+//GERC
+void cgerc_(int *m, int *n, complex       *alpha, complex       *x, int *incx,
+            complex       *y, int *incy, complex       *A, int *ldA);
+void zgerc_(int *m, int *n, doublecomplex *alpha, doublecomplex *x, int *incx, 
+            doublecomplex *y, int *incy, doublecomplex *A, int *ldA);
+
+//GREU
+void cgeru_(int *m, int *n, complex       *alpha, complex       *x, int *incx,
+            complex       *y, int *incy, complex       *A, int *ldA);
+void zgeru_(int *m, int *n, doublecomplex *alpha, doublecomplex *x, int *incx, 
+            doublecomplex *y, int *incy, doublecomplex *A, int *ldA);
+
+//HBMV
+void chbmv_(char *uplo, int *n, int *k, complex       *alpha, complex       *A, int *ldA,
+            complex       *x, int *incx, complex       *beta, complex       *y, int *incy);
+void zhbmv_(char *uplo, int *n, int *k, doublecomplex *alpha, doublecomplex *A, int *ldA,
+            doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy);
+
+//HEMV
+void chemv_(char *uplo, int *n, complex       *alpha, complex       *A, int *ldA,
+            complex       *x, int *incx, complex       *beta, complex       *y, int *incy);
+void zhemv_(char *uplo, int *n, doublecomplex *alpha, doublecomplex *A, int *ldA,
+            doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy);
+
+//HER
+void cher_(char *uplo, int *n, float  *alpha, complex       *x, int *incx, complex       *A, int *ldA);
+void zher_(char *uplo, int *n, double *alpha, doublecomplex *x, int *incx, doublecomplex *A, int *ldA);
+
+//Stub
+//HER2
+
+//HPMV
+void chpmv_(char *uplo, int *n, complex       *alpha, complex       *A,
+            complex       *x, int *incx, complex       *beta, complex       *y, int *incy);
+void zhpmv_(char *uplo, int *n, doublecomplex *alpha, doublecomplex *A,
+            doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy);
+
+//HPR
+void chpr_ (char *uplo, int *n, float   *alpha, complex       *x, int *incx, complex       *A);
+void zhpr_ (char *uplo, int *n, double  *alpha, doublecomplex *x, int *incx, doublecomplex *A);
+
+//Stub
+//HPR2
+
+//SBMV
+void ssbmv_(char *uplo, int *n, int *k, float  *alpha, float  *A, int *ldA,
+            float  *x, int *incx, float  *beta, float  *y, int *incy);
+void dsbmv_(char *uplo, int *n, int *k, double *alpha, double *A, int *ldA,
+            double *x, int *incx, double *beta, double *y, int *incy);
+
+//SPMV
+void sspmv_(char *uplo, int *n, float  *alpha, float  *A, float  *x, int *incx, float  *beta, float  *y, int *incy);
+void dspmv_(char *uplo, int *n, double *alpha, double *A, double *x, int *incx, double *beta, double *y, int *incy);
+
+//SPR
+void sspr_(char *uplo, int *n, float  *alpha, float  *x, int *incx, float  *A);
+void dspr_(char *uplo, int *n, double *alpha, double *x, int *incx, double *A);
+
+//Stub
+//SPR2
+
+//SYMV
+void ssymv_(char *uplo, int *n, float  *alpha, float  *A, int *ldA,
+            float  *x, int *incx, float  *beta, float  *y, int *incy);
+void dsymv_(char *uplo, int *n, double *alpha, double *A, int *ldA,
+            double *x, int *incx, double *beta, double *y, int *incy);
+
+//SYR
+void ssyr_(char *uplo, int *n, float  *alpha, float  *x, int *incx, float  *A, int *ldA);
+void dsyr_(char *uplo, int *n, double *alpha, double *x, int *incx, double *A, int *ldA);
+
+//Stub
+//SYR2
+
+//TBMV
+void stbmv_(char *uplo, char *trans, char *diag, int *n, int *k, float         *A, int *ldA, float         *x, int *incx);
+void dtbmv_(char *uplo, char *trans, char *diag, int *n, int *k, double        *A, int *ldA, double        *x, int *incx);
+void ctbmv_(char *uplo, char *trans, char *diag, int *n, int *k, complex       *A, int *ldA, complex       *x, int *incx);
+void ztbmv_(char *uplo, char *trans, char *diag, int *n, int *k, doublecomplex *A, int *ldA, doublecomplex *x, int *incx);
+
+//TBSV
+void stbsv_(char *uplo, char *trans, char *diag, int *n, int *k, float         *A, int *ldA, float         *x, int *incx);
+void dtbsv_(char *uplo, char *trans, char *diag, int *n, int *k, double        *A, int *ldA, double        *x, int *incx);
+void ctbsv_(char *uplo, char *trans, char *diag, int *n, int *k, complex       *A, int *ldA, complex       *x, int *incx);
+void ztbsv_(char *uplo, char *trans, char *diag, int *n, int *k, doublecomplex *A, int *ldA, doublecomplex *x, int *incx);
+
+//TPMV
+void stpmv_(char *uplo, char *trans, char *diag, int *n, float         *A, float         *x, int *incx);
+void dtpmv_(char *uplo, char *trans, char *diag, int *n, double        *A, double        *x, int *incx);
+void ctpmv_(char *uplo, char *trans, char *diag, int *n, complex       *A, complex       *x, int *incx);
+void ztpmv_(char *uplo, char *trans, char *diag, int *n, doublecomplex *A, doublecomplex *x, int *incx);
+
+//TPSV
+void stpsv_(char *uplo, char *trans, char *diag, int *n, float         *A, float         *x, int *incx);
+void dtpsv_(char *uplo, char *trans, char *diag, int *n, double        *A, double        *x, int *incx);
+void ctpsv_(char *uplo, char *trans, char *diag, int *n, complex       *A, complex       *x, int *incx);
+void ztpsv_(char *uplo, char *trans, char *diag, int *n, doublecomplex *A, doublecomplex *x, int *incx);
+
+//TRSV
+void strsv_(char *uplo, char *trans, char *diag, int *n, float         *A, int *ldA, float         *x, int *incx);
+void dtrsv_(char *uplo, char *trans, char *diag, int *n, double        *A, int *ldA, double        *x, int *incx);
+void ctrsv_(char *uplo, char *trans, char *diag, int *n, complex       *A, int *ldA, complex       *x, int *incx);
+void ztrsv_(char *uplo, char *trans, char *diag, int *n, doublecomplex *A, int *ldA, doublecomplex *x, int *incx);
+
+//TRMV
+void strmv_(char *uplo, char *trans, char *diag, int *n, float         *A, int *ldA, float         *x, int *incx);
+void dtrmv_(char *uplo, char *trans, char *diag, int *n, double        *A, int *ldA, double        *x, int *incx);
+void ctrmv_(char *uplo, char *trans, char *diag, int *n, complex       *A, int *ldA, complex       *x, int *incx);
+void ztrmv_(char *uplo, char *trans, char *diag, int *n, doublecomplex *A, int *ldA, doublecomplex *x, int *incx);
+
+//Level3
+
+//GEMM
+void sgemm_(const char *transa, const char *transb, const int *m, const int *n, const int *k,
+            const float         *alpha, const float         *A, const int *ldA, const float         *B, const int *ldB, 
+            const float         *beta , float         *C, const int *ldC);
+void dgemm_(const char *transa, const char *transb, const int *m, const int *n, const int *k, 
+            const double        *alpha, const double        *A, const int *ldA, const double        *B, const int *ldB, 
+            const double        *beta , double        *C, const int *ldC);
+void cgemm_(const char *transa, const char *transb, const int *m, const int *n, const int *k, 
+            const complex       *alpha, const complex       *A, const int *ldA, const complex       *B, const int *ldB, 
+            const complex       *beta , complex       *C, const int *ldC);
+void zgemm_(const char *transa, const char *transb, const int *m, const int *n, const int *k,
+            const doublecomplex *alpha, const doublecomplex *A, const int *ldA, const doublecomplex *B, const int *ldB, 
+            const doublecomplex *beta , doublecomplex *C, const int *ldC);
+
+//HEMM
+void chemm_(char *side, char *uplo, int *m, int *n, complex       *alpha, complex       *A, int *ldA,
+            complex       *B, int *ldB, complex       *beta, complex       *C, int *ldC);
+void zhemm_(char *side, char *uplo, int *m, int *n, doublecomplex *alpha, doublecomplex *A, int *ldA,
+            doublecomplex *B, int *ldB, doublecomplex *beta, doublecomplex *C, int *ldC);
+
+//HERK
+void cherk_(char *uplo, char *trans, int *n, int *k, float  *alpha, complex       *A, int *ldA,
+            float  *beta , complex       *C, int *ldC);
+void zherk_(char *uplo, char *trans, int *n, int *k, double *aplha, doublecomplex *A, int *ldA,
+            double *beta , doublecomplex *C, int *ldC);
+
+//HERK2
+void cher2k_(char *uplo, char *trans, int *n, int *k, complex       *alpha, complex       *A, int *ldA,
+             complex       *B, int *ldB,float  *beta, complex       *C, int *ldC);
+void zher2k_(char *uplo, char *trans, int *n, int *k, doublecomplex *alpha, doublecomplex *A, int *ldA,
+             doublecomplex *B, int *ldB,double *beta, doublecomplex *C, int *ldC);
+
+//SYMM
+void 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);
+void 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);
+void csymm_(char *side, char *uplo, int *m, int *n, 
+            complex       *alpha, complex       *A, int *ldA, complex       *B, int *ldB, 
+            complex       *beta , complex       *C, int *ldC);
+void zsymm_(char *side, char *uplo, int *m, int *n, 
+            doublecomplex *alpha, doublecomplex *A, int *ldA, doublecomplex *B, int *ldB, 
+            doublecomplex *beta , doublecomplex *C, int *ldC);
+
+//SYRK
+void ssyrk_(char *uplo, char *trans, int *n, int *k, float  *alpha, float         *A, int *ldA,
+            float  *beta , float         *C, int *ldC);
+void dsyrk_(char *uplo, char *trans, int *n, int *k, double *alpha, double        *A, int *ldA,
+            double *beta , double        *C, int *ldC);
+void csyrk_(char *uplo, char *trans, int *n, int *k, float  *alpha, complex       *A, int *ldA,
+            float  *beta , complex       *C, int *ldC);
+void zsyrk_(char *uplo, char *trans, int *n, int *k, double *aplha, doublecomplex *A, int *ldA,
+            double *beta , doublecomplex *C, int *ldC);
+
+//SYR2K
+void 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);
+void 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);
+void csyr2k_(char *uplo, char *trans, int *n, int *k, float  *alpha, complex       *A, int *ldA, complex       *B, int *ldB,
+            float  *beta , complex       *C, int *ldC);
+void zsyr2k_(char *uplo, char *trans, int *n, int *k, double *aplha, doublecomplex *A, int *ldA, doublecomplex *B, int *ldB,
+            double *beta , doublecomplex *C, int *ldC);
+
+//TRMM
+void strmm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            float         *alpha, float         *A, int *ldA, float         *B, int *ldB);
+void dtrmm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            double        *alpha, double        *A, int *ldA, double        *B, int *ldB);
+void ctrmm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            complex       *alpha, complex       *A, int *ldA, complex       *B, int *ldB);
+void ztrmm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            doublecomplex *alpha, doublecomplex *A, int *ldA, doublecomplex *B, int *ldB);
+
+//TRSM
+void strsm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            float         *alpha, float         *A, int *ldA, float         *B, int *ldB);
+void dtrsm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            double        *alpha, double        *A, int *ldA, double        *B, int *ldB);
+void ctrsm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            complex       *alpha, complex       *A, int *ldA, complex       *B, int *ldB);
+void ztrsm_(char *side, char *uplo, char *trans, char *diag, int *m, int *n, 
+            doublecomplex *alpha, doublecomplex *A, int *ldA, doublecomplex *B, int *ldB);
+
+#undef complex
+#undef doublecomplex
+#define complex _Complex
+
+#ifdef __cplusplus 
+}
+#endif
+
+#endif
+