ruby-lapack 1.4.1a → 1.5

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/clean"
 require "rake/gempackagetask"
 require "rake/testtask"
 
-version = "1.4.1a"
+version = 1.5
 target_prefix = "numru"
 
 # get options
@@ -113,7 +113,6 @@ task :binary_package => binary_pkg
 file binary_pkg => so_file do
   files = PKG_FILES.dup
   files.include so_file
-  files.exclude "ext"
   spec.platform = Gem::Platform::CURRENT
   spec.files = files
   spec.extensions = []

data/ext/cbbcsd.c

@@ -104,6 +104,9 @@ rblapack_cbbcsd(int argc, VALUE *argv, VALUE self){
     rblapack_lrwork = Qnil;
   }
 
+  jobu1 = StringValueCStr(rblapack_jobu1)[0];
+  jobv1t = StringValueCStr(rblapack_jobv1t)[0];
+  trans = StringValueCStr(rblapack_trans)[0];
   if (!NA_IsNArray(rblapack_theta))
     rb_raise(rb_eArgError, "theta (7th argument) must be NArray");
   if (NA_RANK(rblapack_theta) != 1)
@@ -112,7 +115,15 @@ rblapack_cbbcsd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_theta) != NA_SFLOAT)
     rblapack_theta = na_change_type(rblapack_theta, NA_SFLOAT);
   theta = NA_PTR_TYPE(rblapack_theta, real*);
-  m = NUM2INT(rblapack_m);
+  if (!NA_IsNArray(rblapack_u1))
+    rb_raise(rb_eArgError, "u1 (9th argument) must be NArray");
+  if (NA_RANK(rblapack_u1) != 2)
+    rb_raise(rb_eArgError, "rank of u1 (9th argument) must be %d", 2);
+  ldu1 = NA_SHAPE0(rblapack_u1);
+  p = NA_SHAPE1(rblapack_u1);
+  if (NA_TYPE(rblapack_u1) != NA_SCOMPLEX)
+    rblapack_u1 = na_change_type(rblapack_u1, NA_SCOMPLEX);
+  u1 = NA_PTR_TYPE(rblapack_u1, complex*);
   if (!NA_IsNArray(rblapack_v1t))
     rb_raise(rb_eArgError, "v1t (11th argument) must be NArray");
   if (NA_RANK(rblapack_v1t) != 2)
@@ -123,39 +134,9 @@ rblapack_cbbcsd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_v1t) != NA_SCOMPLEX)
     rblapack_v1t = na_change_type(rblapack_v1t, NA_SCOMPLEX);
   v1t = NA_PTR_TYPE(rblapack_v1t, complex*);
-  if (!NA_IsNArray(rblapack_phi))
-    rb_raise(rb_eArgError, "phi (8th argument) must be NArray");
-  if (NA_RANK(rblapack_phi) != 1)
-    rb_raise(rb_eArgError, "rank of phi (8th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_phi) != (q-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of phi must be %d", q-1);
-  if (NA_TYPE(rblapack_phi) != NA_SFLOAT)
-    rblapack_phi = na_change_type(rblapack_phi, NA_SFLOAT);
-  phi = NA_PTR_TYPE(rblapack_phi, real*);
-  jobv2t = StringValueCStr(rblapack_jobv2t)[0];
-  trans = StringValueCStr(rblapack_trans)[0];
-  jobu1 = StringValueCStr(rblapack_jobu1)[0];
+  lrwork = MAX(1,8*q);
   jobu2 = StringValueCStr(rblapack_jobu2)[0];
-  if (!NA_IsNArray(rblapack_u1))
-    rb_raise(rb_eArgError, "u1 (9th argument) must be NArray");
-  if (NA_RANK(rblapack_u1) != 2)
-    rb_raise(rb_eArgError, "rank of u1 (9th argument) must be %d", 2);
-  ldu1 = NA_SHAPE0(rblapack_u1);
-  p = NA_SHAPE1(rblapack_u1);
-  if (NA_TYPE(rblapack_u1) != NA_SCOMPLEX)
-    rblapack_u1 = na_change_type(rblapack_u1, NA_SCOMPLEX);
-  u1 = NA_PTR_TYPE(rblapack_u1, complex*);
-  jobv1t = StringValueCStr(rblapack_jobv1t)[0];
-  if (!NA_IsNArray(rblapack_v2t))
-    rb_raise(rb_eArgError, "v2t (12th argument) must be NArray");
-  if (NA_RANK(rblapack_v2t) != 2)
-    rb_raise(rb_eArgError, "rank of v2t (12th argument) must be %d", 2);
-  ldv2t = NA_SHAPE0(rblapack_v2t);
-  if (NA_SHAPE1(rblapack_v2t) != (m-q))
-    rb_raise(rb_eRuntimeError, "shape 1 of v2t must be %d", m-q);
-  if (NA_TYPE(rblapack_v2t) != NA_SCOMPLEX)
-    rblapack_v2t = na_change_type(rblapack_v2t, NA_SCOMPLEX);
-  v2t = NA_PTR_TYPE(rblapack_v2t, complex*);
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_u2))
     rb_raise(rb_eArgError, "u2 (10th argument) must be NArray");
   if (NA_RANK(rblapack_u2) != 2)
@@ -166,7 +147,26 @@ rblapack_cbbcsd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_u2) != NA_SCOMPLEX)
     rblapack_u2 = na_change_type(rblapack_u2, NA_SCOMPLEX);
   u2 = NA_PTR_TYPE(rblapack_u2, complex*);
-  lrwork = MAX(1,8*q);
+  jobv2t = StringValueCStr(rblapack_jobv2t)[0];
+  if (!NA_IsNArray(rblapack_v2t))
+    rb_raise(rb_eArgError, "v2t (12th argument) must be NArray");
+  if (NA_RANK(rblapack_v2t) != 2)
+    rb_raise(rb_eArgError, "rank of v2t (12th argument) must be %d", 2);
+  ldv2t = NA_SHAPE0(rblapack_v2t);
+  if (NA_SHAPE1(rblapack_v2t) != (m-q))
+    rb_raise(rb_eRuntimeError, "shape 1 of v2t must be %d", m-q);
+  if (NA_TYPE(rblapack_v2t) != NA_SCOMPLEX)
+    rblapack_v2t = na_change_type(rblapack_v2t, NA_SCOMPLEX);
+  v2t = NA_PTR_TYPE(rblapack_v2t, complex*);
+  if (!NA_IsNArray(rblapack_phi))
+    rb_raise(rb_eArgError, "phi (8th argument) must be NArray");
+  if (NA_RANK(rblapack_phi) != 1)
+    rb_raise(rb_eArgError, "rank of phi (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_phi) != (q-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of phi must be %d", q-1);
+  if (NA_TYPE(rblapack_phi) != NA_SFLOAT)
+    rblapack_phi = na_change_type(rblapack_phi, NA_SFLOAT);
+  phi = NA_PTR_TYPE(rblapack_phi, real*);
   {
     int shape[1];
     shape[0] = q;

data/ext/cbdsqr.c

@@ -68,6 +68,24 @@ rblapack_cbdsqr(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  uplo = StringValueCStr(rblapack_uplo)[0];
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (3th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (3th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_d);
+  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
+    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
+  d = NA_PTR_TYPE(rblapack_d, real*);
+  if (!NA_IsNArray(rblapack_vt))
+    rb_raise(rb_eArgError, "vt (5th argument) must be NArray");
+  if (NA_RANK(rblapack_vt) != 2)
+    rb_raise(rb_eArgError, "rank of vt (5th argument) must be %d", 2);
+  ldvt = NA_SHAPE0(rblapack_vt);
+  ncvt = NA_SHAPE1(rblapack_vt);
+  if (NA_TYPE(rblapack_vt) != NA_SCOMPLEX)
+    rblapack_vt = na_change_type(rblapack_vt, NA_SCOMPLEX);
+  vt = NA_PTR_TYPE(rblapack_vt, complex*);
   if (!NA_IsNArray(rblapack_c))
     rb_raise(rb_eArgError, "c (7th argument) must be NArray");
   if (NA_RANK(rblapack_c) != 2)
@@ -83,28 +101,11 @@ rblapack_cbdsqr(int argc, VALUE *argv, VALUE self){
   if (NA_RANK(rblapack_u) != 2)
     rb_raise(rb_eArgError, "rank of u (6th argument) must be %d", 2);
   ldu = NA_SHAPE0(rblapack_u);
-  n = NA_SHAPE1(rblapack_u);
+  if (NA_SHAPE1(rblapack_u) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of u must be the same as shape 0 of d");
   if (NA_TYPE(rblapack_u) != NA_SCOMPLEX)
     rblapack_u = na_change_type(rblapack_u, NA_SCOMPLEX);
   u = NA_PTR_TYPE(rblapack_u, complex*);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (3th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_d) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 1 of u");
-  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
-    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
-  d = NA_PTR_TYPE(rblapack_d, real*);
-  if (!NA_IsNArray(rblapack_vt))
-    rb_raise(rb_eArgError, "vt (5th argument) must be NArray");
-  if (NA_RANK(rblapack_vt) != 2)
-    rb_raise(rb_eArgError, "rank of vt (5th argument) must be %d", 2);
-  ldvt = NA_SHAPE0(rblapack_vt);
-  ncvt = NA_SHAPE1(rblapack_vt);
-  if (NA_TYPE(rblapack_vt) != NA_SCOMPLEX)
-    rblapack_vt = na_change_type(rblapack_vt, NA_SCOMPLEX);
-  vt = NA_PTR_TYPE(rblapack_vt, complex*);
   if (!NA_IsNArray(rblapack_e))
     rb_raise(rb_eArgError, "e (4th argument) must be NArray");
   if (NA_RANK(rblapack_e) != 1)
@@ -114,7 +115,6 @@ rblapack_cbdsqr(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_e) != NA_SFLOAT)
     rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
   e = NA_PTR_TYPE(rblapack_e, real*);
-  uplo = StringValueCStr(rblapack_uplo)[0];
   {
     int shape[1];
     shape[0] = n;

data/ext/cgbbrd.c

@@ -66,16 +66,8 @@ rblapack_cgbbrd(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ab))
-    rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ab) != 2)
-    rb_raise(rb_eArgError, "rank of ab (4th argument) must be %d", 2);
-  ldab = NA_SHAPE0(rblapack_ab);
-  n = NA_SHAPE1(rblapack_ab);
-  if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
-    rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
-  ab = NA_PTR_TYPE(rblapack_ab, complex*);
-  m = ldab;
+  vect = StringValueCStr(rblapack_vect)[0];
+  ku = NUM2INT(rblapack_ku);
   if (!NA_IsNArray(rblapack_c))
     rb_raise(rb_eArgError, "c (5th argument) must be NArray");
   if (NA_RANK(rblapack_c) != 2)
@@ -85,10 +77,18 @@ rblapack_cgbbrd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_c) != NA_SCOMPLEX)
     rblapack_c = na_change_type(rblapack_c, NA_SCOMPLEX);
   c = NA_PTR_TYPE(rblapack_c, complex*);
-  ku = NUM2INT(rblapack_ku);
   kl = NUM2INT(rblapack_kl);
-  vect = StringValueCStr(rblapack_vect)[0];
+  if (!NA_IsNArray(rblapack_ab))
+    rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
+  if (NA_RANK(rblapack_ab) != 2)
+    rb_raise(rb_eArgError, "rank of ab (4th argument) must be %d", 2);
+  ldab = NA_SHAPE0(rblapack_ab);
+  n = NA_SHAPE1(rblapack_ab);
+  if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
+    rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
+  ab = NA_PTR_TYPE(rblapack_ab, complex*);
   ldpt = ((lsame_(&vect,"P")) || (lsame_(&vect,"B"))) ? MAX(1,n) : 1;
+  m = ldab;
   ldq = ((lsame_(&vect,"Q")) || (lsame_(&vect,"B"))) ? MAX(1,m) : 1;
   {
     int shape[1];

data/ext/cgbcon.c

@@ -54,28 +54,28 @@ rblapack_cgbcon(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  anorm = (real)NUM2DBL(rblapack_anorm);
-  if (!NA_IsNArray(rblapack_ab))
-    rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ab) != 2)
-    rb_raise(rb_eArgError, "rank of ab (4th argument) must be %d", 2);
-  ldab = NA_SHAPE0(rblapack_ab);
-  n = NA_SHAPE1(rblapack_ab);
-  if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
-    rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
-  ab = NA_PTR_TYPE(rblapack_ab, complex*);
   norm = StringValueCStr(rblapack_norm)[0];
+  ku = NUM2INT(rblapack_ku);
   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);
-  if (NA_SHAPE0(rblapack_ipiv) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be the same as shape 1 of ab");
+  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*);
-  ku = NUM2INT(rblapack_ku);
   kl = NUM2INT(rblapack_kl);
+  anorm = (real)NUM2DBL(rblapack_anorm);
+  if (!NA_IsNArray(rblapack_ab))
+    rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
+  if (NA_RANK(rblapack_ab) != 2)
+    rb_raise(rb_eArgError, "rank of ab (4th argument) must be %d", 2);
+  ldab = NA_SHAPE0(rblapack_ab);
+  if (NA_SHAPE1(rblapack_ab) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 0 of ipiv");
+  if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
+    rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
+  ab = NA_PTR_TYPE(rblapack_ab, complex*);
   work = ALLOC_N(complex, (2*n));
   rwork = ALLOC_N(real, (n));
 

data/ext/cgbequ.c

@@ -54,6 +54,9 @@ rblapack_cgbequ(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  m = NUM2INT(rblapack_m);
+  ku = NUM2INT(rblapack_ku);
+  kl = NUM2INT(rblapack_kl);
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
@@ -63,9 +66,6 @@ rblapack_cgbequ(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, complex*);
-  m = NUM2INT(rblapack_m);
-  kl = NUM2INT(rblapack_kl);
-  ku = NUM2INT(rblapack_ku);
   {
     int shape[1];
     shape[0] = MAX(1,m);

data/ext/cgbequb.c

@@ -52,6 +52,7 @@ rblapack_cgbequb(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  kl = NUM2INT(rblapack_kl);
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (3th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
@@ -61,9 +62,8 @@ rblapack_cgbequb(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_ab) != NA_DFLOAT)
     rblapack_ab = na_change_type(rblapack_ab, NA_DFLOAT);
   ab = NA_PTR_TYPE(rblapack_ab, doublereal*);
-  m = ldab;
-  kl = NUM2INT(rblapack_kl);
   ku = NUM2INT(rblapack_ku);
+  m = ldab;
   {
     int shape[1];
     shape[0] = m;

data/ext/cgbrfs.c

@@ -68,15 +68,17 @@ rblapack_cgbrfs(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (6th 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*);
-  kl = NUM2INT(rblapack_kl);
+  trans = StringValueCStr(rblapack_trans)[0];
+  ku = NUM2INT(rblapack_ku);
+  if (!NA_IsNArray(rblapack_afb))
+    rb_raise(rb_eArgError, "afb (5th argument) must be NArray");
+  if (NA_RANK(rblapack_afb) != 2)
+    rb_raise(rb_eArgError, "rank of afb (5th argument) must be %d", 2);
+  ldafb = NA_SHAPE0(rblapack_afb);
+  n = NA_SHAPE1(rblapack_afb);
+  if (NA_TYPE(rblapack_afb) != NA_SCOMPLEX)
+    rblapack_afb = na_change_type(rblapack_afb, NA_SCOMPLEX);
+  afb = NA_PTR_TYPE(rblapack_afb, complex*);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (7th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -86,27 +88,26 @@ rblapack_cgbrfs(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_b) != NA_SCOMPLEX)
     rblapack_b = na_change_type(rblapack_b, NA_SCOMPLEX);
   b = NA_PTR_TYPE(rblapack_b, complex*);
-  ku = NUM2INT(rblapack_ku);
+  kl = NUM2INT(rblapack_kl);
+  if (!NA_IsNArray(rblapack_ipiv))
+    rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
+  if (NA_RANK(rblapack_ipiv) != 1)
+    rb_raise(rb_eArgError, "rank of ipiv (6th 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 afb");
+  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_ab))
     rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
     rb_raise(rb_eArgError, "rank of ab (4th argument) must be %d", 2);
   ldab = NA_SHAPE0(rblapack_ab);
   if (NA_SHAPE1(rblapack_ab) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 1 of afb");
   if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, complex*);
-  if (!NA_IsNArray(rblapack_afb))
-    rb_raise(rb_eArgError, "afb (5th argument) must be NArray");
-  if (NA_RANK(rblapack_afb) != 2)
-    rb_raise(rb_eArgError, "rank of afb (5th argument) must be %d", 2);
-  ldafb = NA_SHAPE0(rblapack_afb);
-  if (NA_SHAPE1(rblapack_afb) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of afb must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_afb) != NA_SCOMPLEX)
-    rblapack_afb = na_change_type(rblapack_afb, NA_SCOMPLEX);
-  afb = NA_PTR_TYPE(rblapack_afb, complex*);
   if (!NA_IsNArray(rblapack_x))
     rb_raise(rb_eArgError, "x (8th argument) must be NArray");
   if (NA_RANK(rblapack_x) != 2)
@@ -117,7 +118,6 @@ rblapack_cgbrfs(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
     rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
   x = NA_PTR_TYPE(rblapack_x, complex*);
-  trans = StringValueCStr(rblapack_trans)[0];
   {
     int shape[1];
     shape[0] = nrhs;

data/ext/cgbrfsx.c

@@ -92,73 +92,45 @@ rblapack_cgbrfsx(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (7th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (7th 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*);
-  kl = NUM2INT(rblapack_kl);
-  if (!NA_IsNArray(rblapack_b))
-    rb_raise(rb_eArgError, "b (10th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (10th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  nrhs = NA_SHAPE1(rblapack_b);
-  if (NA_TYPE(rblapack_b) != NA_SFLOAT)
-    rblapack_b = na_change_type(rblapack_b, NA_SFLOAT);
-  b = NA_PTR_TYPE(rblapack_b, real*);
-  if (!NA_IsNArray(rblapack_r))
-    rb_raise(rb_eArgError, "r (8th argument) must be NArray");
-  if (NA_RANK(rblapack_r) != 1)
-    rb_raise(rb_eArgError, "rank of r (8th 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");
-  if (NA_TYPE(rblapack_r) != NA_SFLOAT)
-    rblapack_r = na_change_type(rblapack_r, NA_SFLOAT);
-  r = NA_PTR_TYPE(rblapack_r, real*);
-  n_err_bnds = 3;
-  ku = NUM2INT(rblapack_ku);
   trans = StringValueCStr(rblapack_trans)[0];
+  kl = NUM2INT(rblapack_kl);
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (5th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
     rb_raise(rb_eArgError, "rank of ab (5th argument) must be %d", 2);
   ldab = NA_SHAPE0(rblapack_ab);
-  if (NA_SHAPE1(rblapack_ab) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 0 of ipiv");
+  n = NA_SHAPE1(rblapack_ab);
   if (NA_TYPE(rblapack_ab) != NA_DFLOAT)
     rblapack_ab = na_change_type(rblapack_ab, NA_DFLOAT);
   ab = NA_PTR_TYPE(rblapack_ab, doublereal*);
+  if (!NA_IsNArray(rblapack_ipiv))
+    rb_raise(rb_eArgError, "ipiv (7th argument) must be NArray");
+  if (NA_RANK(rblapack_ipiv) != 1)
+    rb_raise(rb_eArgError, "rank of ipiv (7th 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 ab");
+  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 (9th argument) must be NArray");
   if (NA_RANK(rblapack_c) != 1)
     rb_raise(rb_eArgError, "rank of c (9th 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");
+    rb_raise(rb_eRuntimeError, "shape 0 of c must be the same as shape 1 of ab");
   if (NA_TYPE(rblapack_c) != NA_SFLOAT)
     rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
   c = NA_PTR_TYPE(rblapack_c, real*);
-  if (!NA_IsNArray(rblapack_params))
-    rb_raise(rb_eArgError, "params (12th argument) must be NArray");
-  if (NA_RANK(rblapack_params) != 1)
-    rb_raise(rb_eArgError, "rank of params (12th argument) must be %d", 1);
-  nparams = NA_SHAPE0(rblapack_params);
-  if (NA_TYPE(rblapack_params) != NA_SFLOAT)
-    rblapack_params = na_change_type(rblapack_params, NA_SFLOAT);
-  params = NA_PTR_TYPE(rblapack_params, real*);
   if (!NA_IsNArray(rblapack_x))
     rb_raise(rb_eArgError, "x (11th argument) must be NArray");
   if (NA_RANK(rblapack_x) != 2)
     rb_raise(rb_eArgError, "rank of x (11th 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");
+  nrhs = NA_SHAPE1(rblapack_x);
   if (NA_TYPE(rblapack_x) != NA_SFLOAT)
     rblapack_x = na_change_type(rblapack_x, NA_SFLOAT);
   x = NA_PTR_TYPE(rblapack_x, real*);
+  n_err_bnds = 3;
   equed = StringValueCStr(rblapack_equed)[0];
   if (!NA_IsNArray(rblapack_afb))
     rb_raise(rb_eArgError, "afb (6th argument) must be NArray");
@@ -166,10 +138,38 @@ rblapack_cgbrfsx(int argc, VALUE *argv, VALUE self){
     rb_raise(rb_eArgError, "rank of afb (6th argument) must be %d", 2);
   ldafb = NA_SHAPE0(rblapack_afb);
   if (NA_SHAPE1(rblapack_afb) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of afb must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 1 of afb must be the same as shape 1 of ab");
   if (NA_TYPE(rblapack_afb) != NA_DFLOAT)
     rblapack_afb = na_change_type(rblapack_afb, NA_DFLOAT);
   afb = NA_PTR_TYPE(rblapack_afb, doublereal*);
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (10th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (10th 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_SFLOAT)
+    rblapack_b = na_change_type(rblapack_b, NA_SFLOAT);
+  b = NA_PTR_TYPE(rblapack_b, real*);
+  ku = NUM2INT(rblapack_ku);
+  if (!NA_IsNArray(rblapack_params))
+    rb_raise(rb_eArgError, "params (12th argument) must be NArray");
+  if (NA_RANK(rblapack_params) != 1)
+    rb_raise(rb_eArgError, "rank of params (12th argument) must be %d", 1);
+  nparams = NA_SHAPE0(rblapack_params);
+  if (NA_TYPE(rblapack_params) != NA_SFLOAT)
+    rblapack_params = na_change_type(rblapack_params, NA_SFLOAT);
+  params = NA_PTR_TYPE(rblapack_params, real*);
+  if (!NA_IsNArray(rblapack_r))
+    rb_raise(rb_eArgError, "r (8th argument) must be NArray");
+  if (NA_RANK(rblapack_r) != 1)
+    rb_raise(rb_eArgError, "rank of r (8th 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 1 of ab");
+  if (NA_TYPE(rblapack_r) != NA_SFLOAT)
+    rblapack_r = na_change_type(rblapack_r, NA_SFLOAT);
+  r = NA_PTR_TYPE(rblapack_r, real*);
   {
     int shape[1];
     shape[0] = nrhs;