Module: NuLin::Native

Defined in:
lib/nulin.rb,
ext/nulin_native.c

Class Method Summary collapse

Class Method Details

.call(typecode, name, *args) ⇒ Object

Raises:



34
35
36
37
38
39
40
41
 
# File 'lib/nulin.rb', line 34

def call(typecode, name, *args)
  fun_name = LAPACK_PREFIX[typecode] + name
  retvals = __send__(fun_name, *args)
  info = retvals ? retvals.last : 0
  raise LinalgError, "#{fun_name}: errno #{info}" if info != 0

  return retvals
end

.cgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info) ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'ext/nulin_native.c', line 84

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));
}

.cgelqf(m, n, a, lda, tau, work, lwork, info) ⇒ Object 



236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'ext/nulin_native.c', line 236

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));
}

.cgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) ⇒ Object 



369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'ext/nulin_native.c', line 369

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));
}

.cgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info) ⇒ Object 



448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
 
# File 'ext/nulin_native.c', line 448

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));
}

.cgemm(transa, transb, n, m, k, alpha, a, lda, b, ldb, beta, c, ldc) ⇒ Object 



577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
 
# File 'ext/nulin_native.c', line 577

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;
}

.cgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'ext/nulin_native.c', line 169

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));
}

.cpotrf(uplo, n, a, lda, info) ⇒ Object 



505
506
507
508
509
510
511
512
513
514
 
# File 'ext/nulin_native.c', line 505

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));
}

.cunglq(m, n, k, a, lda, tau, work, lwork, info) ⇒ Object 



299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'ext/nulin_native.c', line 299

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));
}

.dgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'ext/nulin_native.c', line 21

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));
}

.dgelqf(m, n, a, lda, tau, work, lwork, info) ⇒ Object 



191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'ext/nulin_native.c', line 191

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));
}

.dgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) ⇒ Object 



315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
 
# File 'ext/nulin_native.c', line 315

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));
}

.dgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info) ⇒ Object 



387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
 
# File 'ext/nulin_native.c', line 387

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));
}

.dgemm(transa, transb, n, m, k, alpha, a, lda, b, ldb, beta, c, ldc) ⇒ Object 



517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'ext/nulin_native.c', line 517

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;
}

.dgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'ext/nulin_native.c', line 105

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));
}

.dorglq(m, n, k, a, lda, tau, work, lwork, info) ⇒ Object 



251
252
253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'ext/nulin_native.c', line 251

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));
}

.dpotrf(uplo, n, a, lda, info) ⇒ Object 



469
470
471
472
473
474
475
476
477
478
 
# File 'ext/nulin_native.c', line 469

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));
}

.sgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'ext/nulin_native.c', line 42

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));
}

.sgelqf(m, n, a, lda, tau, work, lwork, info) ⇒ Object 



206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'ext/nulin_native.c', line 206

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));
}

.sgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) ⇒ Object 



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
 
# File 'ext/nulin_native.c', line 333

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));
}

.sgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info) ⇒ Object 



407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
 
# File 'ext/nulin_native.c', line 407

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));
}

.sgemm(transa, transb, n, m, k, alpha, a, lda, b, ldb, beta, c, ldc) ⇒ Object 



537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
 
# File 'ext/nulin_native.c', line 537

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;
}

.sgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'ext/nulin_native.c', line 126

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));
}

.sorglq(m, n, k, a, lda, tau, work, lwork, info) ⇒ Object 



267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# File 'ext/nulin_native.c', line 267

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));
}

.spotrf(uplo, n, a, lda, info) ⇒ Object 



481
482
483
484
485
486
487
488
489
490
 
# File 'ext/nulin_native.c', line 481

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));
}

.zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'ext/nulin_native.c', line 63

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));
}

.zgelqf(m, n, a, lda, tau, work, lwork, info) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'ext/nulin_native.c', line 221

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));
}

.zgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) ⇒ Object 



351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'ext/nulin_native.c', line 351

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));
}

.zgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info) ⇒ Object 



427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
 
# File 'ext/nulin_native.c', line 427

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));
}

.zgemm(transa, transb, n, m, k, alpha, a, lda, b, ldb, beta, c, ldc) ⇒ Object 



557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
 
# File 'ext/nulin_native.c', line 557

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;
}

.zgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info) ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'ext/nulin_native.c', line 147

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));
}

.zpotrf(uplo, n, a, lda, info) ⇒ Object 



493
494
495
496
497
498
499
500
501
502
 
# File 'ext/nulin_native.c', line 493

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));
}

.zunglq(m, n, k, a, lda, tau, work, lwork, info) ⇒ Object 



283
284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'ext/nulin_native.c', line 283

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));
}