ruby-lapack 1.4.1a → 1.5

data/ext/zgelsd.c

@@ -30,13 +30,13 @@ rblapack_zgelsd(int argc, VALUE *argv, VALUE self){
   integer n;
   integer m;
   integer nrhs;
+  integer ldb;
   integer c__9;
   integer c__0;
-  integer lrwork;
   integer liwork;
-  integer smlsiz;
+  integer lrwork;
   integer nlvl;
-  integer ldb;
+  integer smlsiz;
 
   VALUE rblapack_options;
   if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
@@ -65,7 +65,6 @@ rblapack_zgelsd(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
-  c__9 = 9;
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (1th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -75,11 +74,9 @@ rblapack_zgelsd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  c__0 = 0;
-  smlsiz = ilaenv_(&c__9,"ZGELSD"," ",&c__0,&c__0,&c__0,&c__0);
   rcond = NUM2DBL(rblapack_rcond);
   m = lda;
-  nlvl = MAX(0,(int)(log(1.0*MIN(m,n)/(smlsiz+1))/log(2.0)));
+  c__9 = 9;
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (2th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -90,14 +87,17 @@ rblapack_zgelsd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
     rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
   b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
-  lrwork = m>=n ? 10*n+2*n*smlsiz+8*n*nlvl+3*smlsiz*nrhs+(smlsiz+1)*(smlsiz+1) : 10*m+2*m*smlsiz+8*m*nlvl+2*smlsiz*nrhs+(smlsiz+1)*(smlsiz+1);
   ldb = MAX(m,n);
-  liwork = MAX(1,3*(MIN(m,n))*nlvl+11*(MIN(m,n)));
   if (rblapack_lwork == Qnil)
     lwork = m>=n ? 2*n+n*nrhs : 2*m+m*nrhs;
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
+  c__0 = 0;
+  smlsiz = ilaenv_(&c__9,"ZGELSD"," ",&c__0,&c__0,&c__0,&c__0);
+  nlvl = MAX(0,(int)(log(1.0*MIN(m,n)/(smlsiz+1))/log(2.0)));
+  liwork = MAX(1,3*(MIN(m,n))*nlvl+11*(MIN(m,n)));
+  lrwork = m>=n ? 10*n+2*n*smlsiz+8*n*nlvl+3*smlsiz*nrhs+(smlsiz+1)*(smlsiz+1) : 10*m+2*m*smlsiz+8*m*nlvl+2*smlsiz*nrhs+(smlsiz+1)*(smlsiz+1);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgelss.c

@@ -60,7 +60,6 @@ rblapack_zgelss(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
-  rcond = NUM2DBL(rblapack_rcond);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (1th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -70,8 +69,8 @@ rblapack_zgelss(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  rcond = NUM2DBL(rblapack_rcond);
   m = lda;
-  ldb = MAX(m, n);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (2th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -82,6 +81,7 @@ rblapack_zgelss(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
     rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
   b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
+  ldb = MAX(m, n);
   if (rblapack_lwork == Qnil)
     lwork = 3*MIN(m,n) + MAX(MAX(2*MIN(m,n),MAX(m,n)),nrhs);
   else {

data/ext/zgelsx.c

@@ -59,7 +59,7 @@ rblapack_zgelsx(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  rcond = NUM2DBL(rblapack_rcond);
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (3th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -69,25 +69,25 @@ rblapack_zgelsx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
     rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
   b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
-  if (!NA_IsNArray(rblapack_jpvt))
-    rb_raise(rb_eArgError, "jpvt (4th argument) must be NArray");
-  if (NA_RANK(rblapack_jpvt) != 1)
-    rb_raise(rb_eArgError, "rank of jpvt (4th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_jpvt);
-  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
-    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
-  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
+  rcond = NUM2DBL(rblapack_rcond);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
     rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
   lda = NA_SHAPE0(rblapack_a);
-  if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 0 of jpvt");
+  n = NA_SHAPE1(rblapack_a);
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  m = NUM2INT(rblapack_m);
+  if (!NA_IsNArray(rblapack_jpvt))
+    rb_raise(rb_eArgError, "jpvt (4th argument) must be NArray");
+  if (NA_RANK(rblapack_jpvt) != 1)
+    rb_raise(rb_eArgError, "rank of jpvt (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_jpvt) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of jpvt must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
+    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
+  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
   {
     int shape[2];
     shape[0] = lda;

data/ext/zgelsy.c

@@ -63,27 +63,25 @@ rblapack_zgelsy(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
-  rcond = NUM2DBL(rblapack_rcond);
-  if (!NA_IsNArray(rblapack_jpvt))
-    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
-  if (NA_RANK(rblapack_jpvt) != 1)
-    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_jpvt);
-  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
-    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
-  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (1th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
     rb_raise(rb_eArgError, "rank of a (1th argument) must be %d", 2);
   lda = NA_SHAPE0(rblapack_a);
-  if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 0 of jpvt");
+  n = NA_SHAPE1(rblapack_a);
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  if (!NA_IsNArray(rblapack_jpvt))
+    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
+  if (NA_RANK(rblapack_jpvt) != 1)
+    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_jpvt) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of jpvt must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
+    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
+  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
   m = lda;
-  ldb = MAX(m,n);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (2th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -99,6 +97,8 @@ rblapack_zgelsy(int argc, VALUE *argv, VALUE self){
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
+  rcond = NUM2DBL(rblapack_rcond);
+  ldb = MAX(m,n);
   {
     int shape[1];
     shape[0] = MAX(1,lwork);

data/ext/zgeql2.c

@@ -43,6 +43,7 @@ rblapack_zgeql2(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -52,7 +53,6 @@ rblapack_zgeql2(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgeqlf.c

@@ -49,6 +49,7 @@ rblapack_zgeqlf(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -63,7 +64,6 @@ rblapack_zgeqlf(int argc, VALUE *argv, VALUE self){
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgeqp3.c

@@ -55,25 +55,25 @@ rblapack_zgeqp3(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
+  m = NUM2INT(rblapack_m);
+  if (!NA_IsNArray(rblapack_jpvt))
+    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
+  if (NA_RANK(rblapack_jpvt) != 1)
+    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_jpvt);
+  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
+    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
+  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
     rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
   lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
+  if (NA_SHAPE1(rblapack_a) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 0 of jpvt");
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  if (!NA_IsNArray(rblapack_jpvt))
-    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
-  if (NA_RANK(rblapack_jpvt) != 1)
-    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_jpvt) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of jpvt must be the same as shape 1 of a");
-  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
-    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
-  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
-  m = NUM2INT(rblapack_m);
   if (rblapack_lwork == Qnil)
     lwork = n+1;
   else {

data/ext/zgeqpf.c

@@ -49,25 +49,25 @@ rblapack_zgeqpf(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  m = NUM2INT(rblapack_m);
+  if (!NA_IsNArray(rblapack_jpvt))
+    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
+  if (NA_RANK(rblapack_jpvt) != 1)
+    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_jpvt);
+  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
+    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
+  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
     rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
   lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
+  if (NA_SHAPE1(rblapack_a) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 0 of jpvt");
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  if (!NA_IsNArray(rblapack_jpvt))
-    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
-  if (NA_RANK(rblapack_jpvt) != 1)
-    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_jpvt) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of jpvt must be the same as shape 1 of a");
-  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
-    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
-  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgeqr2.c

@@ -43,6 +43,7 @@ rblapack_zgeqr2(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -52,7 +53,6 @@ rblapack_zgeqr2(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgeqr2p.c

@@ -43,6 +43,7 @@ rblapack_zgeqr2p(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -52,7 +53,6 @@ rblapack_zgeqr2p(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgeqrf.c

@@ -49,6 +49,7 @@ rblapack_zgeqrf(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -63,7 +64,6 @@ rblapack_zgeqrf(int argc, VALUE *argv, VALUE self){
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgeqrfp.c

@@ -49,6 +49,7 @@ rblapack_zgeqrfp(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -63,7 +64,6 @@ rblapack_zgeqrfp(int argc, VALUE *argv, VALUE self){
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
-  m = NUM2INT(rblapack_m);
   {
     int shape[1];
     shape[0] = MIN(m,n);

data/ext/zgerfs.c

@@ -62,54 +62,54 @@ rblapack_zgerfs(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (4th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_ipiv);
-  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
-    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  if (!NA_IsNArray(rblapack_x))
-    rb_raise(rb_eArgError, "x (6th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 2)
-    rb_raise(rb_eArgError, "rank of x (6th argument) must be %d", 2);
-  ldx = NA_SHAPE0(rblapack_x);
-  nrhs = NA_SHAPE1(rblapack_x);
-  if (NA_TYPE(rblapack_x) != NA_DCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_DCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
+  trans = StringValueCStr(rblapack_trans)[0];
   if (!NA_IsNArray(rblapack_af))
     rb_raise(rb_eArgError, "af (3th argument) must be NArray");
   if (NA_RANK(rblapack_af) != 2)
     rb_raise(rb_eArgError, "rank of af (3th argument) must be %d", 2);
   ldaf = NA_SHAPE0(rblapack_af);
-  if (NA_SHAPE1(rblapack_af) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of af must be the same as shape 0 of ipiv");
+  n = NA_SHAPE1(rblapack_af);
   if (NA_TYPE(rblapack_af) != NA_DCOMPLEX)
     rblapack_af = na_change_type(rblapack_af, NA_DCOMPLEX);
   af = NA_PTR_TYPE(rblapack_af, doublecomplex*);
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (5th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (5th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  nrhs = NA_SHAPE1(rblapack_b);
+  if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
+    rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
+  b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (2th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
     rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
   lda = NA_SHAPE0(rblapack_a);
   if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 1 of af");
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  trans = StringValueCStr(rblapack_trans)[0];
-  if (!NA_IsNArray(rblapack_b))
-    rb_raise(rb_eArgError, "b (5th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (5th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  if (NA_SHAPE1(rblapack_b) != nrhs)
-    rb_raise(rb_eRuntimeError, "shape 1 of b must be the same as shape 1 of x");
-  if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
-    rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
-  b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
+  if (!NA_IsNArray(rblapack_x))
+    rb_raise(rb_eArgError, "x (6th argument) must be NArray");
+  if (NA_RANK(rblapack_x) != 2)
+    rb_raise(rb_eArgError, "rank of x (6th argument) must be %d", 2);
+  ldx = NA_SHAPE0(rblapack_x);
+  if (NA_SHAPE1(rblapack_x) != nrhs)
+    rb_raise(rb_eRuntimeError, "shape 1 of x must be the same as shape 1 of b");
+  if (NA_TYPE(rblapack_x) != NA_DCOMPLEX)
+    rblapack_x = na_change_type(rblapack_x, NA_DCOMPLEX);
+  x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
+  if (!NA_IsNArray(rblapack_ipiv))
+    rb_raise(rb_eArgError, "ipiv (4th argument) must be NArray");
+  if (NA_RANK(rblapack_ipiv) != 1)
+    rb_raise(rb_eArgError, "rank of ipiv (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_ipiv) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be the same as shape 1 of af");
+  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
+    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
+  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
   {
     int shape[1];
     shape[0] = nrhs;

data/ext/zgerfsx.c

@@ -82,14 +82,34 @@ rblapack_zgerfsx(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  trans = StringValueCStr(rblapack_trans)[0];
+  if (!NA_IsNArray(rblapack_a))
+    rb_raise(rb_eArgError, "a (3th argument) must be NArray");
+  if (NA_RANK(rblapack_a) != 2)
+    rb_raise(rb_eArgError, "rank of a (3th argument) must be %d", 2);
+  lda = NA_SHAPE0(rblapack_a);
+  n = NA_SHAPE1(rblapack_a);
+  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
   if (!NA_IsNArray(rblapack_ipiv))
     rb_raise(rb_eArgError, "ipiv (5th argument) must be NArray");
   if (NA_RANK(rblapack_ipiv) != 1)
     rb_raise(rb_eArgError, "rank of ipiv (5th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_ipiv);
+  if (NA_SHAPE0(rblapack_ipiv) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be the same as shape 1 of a");
   if (NA_TYPE(rblapack_ipiv) != NA_LINT)
     rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
   ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
+  if (!NA_IsNArray(rblapack_c))
+    rb_raise(rb_eArgError, "c (7th argument) must be NArray");
+  if (NA_RANK(rblapack_c) != 1)
+    rb_raise(rb_eArgError, "rank of c (7th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_c) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of c must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_c) != NA_DFLOAT)
+    rblapack_c = na_change_type(rblapack_c, NA_DFLOAT);
+  c = NA_PTR_TYPE(rblapack_c, doublereal*);
   if (!NA_IsNArray(rblapack_x))
     rb_raise(rb_eArgError, "x (9th argument) must be NArray");
   if (NA_RANK(rblapack_x) != 2)
@@ -99,21 +119,14 @@ rblapack_zgerfsx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_x) != NA_DCOMPLEX)
     rblapack_x = na_change_type(rblapack_x, NA_DCOMPLEX);
   x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
-  if (!NA_IsNArray(rblapack_c))
-    rb_raise(rb_eArgError, "c (7th argument) must be NArray");
-  if (NA_RANK(rblapack_c) != 1)
-    rb_raise(rb_eArgError, "rank of c (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_c) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of c must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_c) != NA_DFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_DFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, doublereal*);
+  n_err_bnds = 3;
+  equed = StringValueCStr(rblapack_equed)[0];
   if (!NA_IsNArray(rblapack_r))
     rb_raise(rb_eArgError, "r (6th argument) must be NArray");
   if (NA_RANK(rblapack_r) != 1)
     rb_raise(rb_eArgError, "rank of r (6th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_r) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of r must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 0 of r must be the same as shape 1 of a");
   if (NA_TYPE(rblapack_r) != NA_DFLOAT)
     rblapack_r = na_change_type(rblapack_r, NA_DFLOAT);
   r = NA_PTR_TYPE(rblapack_r, doublereal*);
@@ -125,28 +138,16 @@ rblapack_zgerfsx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_params) != NA_DFLOAT)
     rblapack_params = na_change_type(rblapack_params, NA_DFLOAT);
   params = NA_PTR_TYPE(rblapack_params, doublereal*);
-  trans = StringValueCStr(rblapack_trans)[0];
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (3th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (3th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
   if (!NA_IsNArray(rblapack_af))
     rb_raise(rb_eArgError, "af (4th argument) must be NArray");
   if (NA_RANK(rblapack_af) != 2)
     rb_raise(rb_eArgError, "rank of af (4th argument) must be %d", 2);
   ldaf = NA_SHAPE0(rblapack_af);
   if (NA_SHAPE1(rblapack_af) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of af must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 1 of af must be the same as shape 1 of a");
   if (NA_TYPE(rblapack_af) != NA_DCOMPLEX)
     rblapack_af = na_change_type(rblapack_af, NA_DCOMPLEX);
   af = NA_PTR_TYPE(rblapack_af, doublecomplex*);
-  equed = StringValueCStr(rblapack_equed)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (8th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -157,7 +158,6 @@ rblapack_zgerfsx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
     rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
   b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
-  n_err_bnds = 3;
   {
     int shape[1];
     shape[0] = nrhs;