ruby-lapack 1.4.1a → 1.5

data/ext/cla_syrcond_c.c

@@ -59,42 +59,13 @@ rblapack_cla_syrcond_c(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_rwork))
-    rb_raise(rb_eArgError, "rwork (8th argument) must be NArray");
-  if (NA_RANK(rblapack_rwork) != 1)
-    rb_raise(rb_eArgError, "rank of rwork (8th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_rwork) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of rwork must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_rwork) != NA_SFLOAT)
-    rblapack_rwork = na_change_type(rblapack_rwork, NA_SFLOAT);
-  rwork = NA_PTR_TYPE(rblapack_rwork, real*);
-  capply = (rblapack_capply == Qtrue);
   uplo = StringValueCStr(rblapack_uplo)[0];
-  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");
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
   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_SCOMPLEX)
     rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
   af = NA_PTR_TYPE(rblapack_af, complex*);
@@ -103,10 +74,39 @@ rblapack_cla_syrcond_c(int argc, VALUE *argv, VALUE self){
   if (NA_RANK(rblapack_c) != 1)
     rb_raise(rb_eArgError, "rank of c (5th 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 af");
   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_rwork))
+    rb_raise(rb_eArgError, "rwork (8th argument) must be NArray");
+  if (NA_RANK(rblapack_rwork) != 1)
+    rb_raise(rb_eArgError, "rank of rwork (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_rwork) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of rwork must be the same as shape 1 of af");
+  if (NA_TYPE(rblapack_rwork) != NA_SFLOAT)
+    rblapack_rwork = na_change_type(rblapack_rwork, NA_SFLOAT);
+  rwork = NA_PTR_TYPE(rblapack_rwork, real*);
+  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 1 of af");
+  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, complex*);
+  capply = (rblapack_capply == Qtrue);
+  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*);
   if (!NA_IsNArray(rblapack_work))
     rb_raise(rb_eArgError, "work (7th argument) must be NArray");
   if (NA_RANK(rblapack_work) != 1)

data/ext/cla_syrcond_x.c

@@ -56,53 +56,53 @@ rblapack_cla_syrcond_x(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 (5th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 1)
-    rb_raise(rb_eArgError, "rank of x (5th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_x) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of x must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, complex*);
+  uplo = StringValueCStr(rblapack_uplo)[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_SCOMPLEX)
     rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
   af = NA_PTR_TYPE(rblapack_af, complex*);
-  uplo = StringValueCStr(rblapack_uplo)[0];
+  if (!NA_IsNArray(rblapack_x))
+    rb_raise(rb_eArgError, "x (5th argument) must be NArray");
+  if (NA_RANK(rblapack_x) != 1)
+    rb_raise(rb_eArgError, "rank of x (5th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_x) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of x must be the same as shape 1 of af");
+  if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
+    rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
+  x = NA_PTR_TYPE(rblapack_x, complex*);
+  if (!NA_IsNArray(rblapack_rwork))
+    rb_raise(rb_eArgError, "rwork (7th argument) must be NArray");
+  if (NA_RANK(rblapack_rwork) != 1)
+    rb_raise(rb_eArgError, "rank of rwork (7th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_rwork) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of rwork must be the same as shape 1 of af");
+  if (NA_TYPE(rblapack_rwork) != NA_SFLOAT)
+    rblapack_rwork = na_change_type(rblapack_rwork, NA_SFLOAT);
+  rwork = NA_PTR_TYPE(rblapack_rwork, real*);
   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_SCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, complex*);
-  if (!NA_IsNArray(rblapack_rwork))
-    rb_raise(rb_eArgError, "rwork (7th argument) must be NArray");
-  if (NA_RANK(rblapack_rwork) != 1)
-    rb_raise(rb_eArgError, "rank of rwork (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_rwork) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of rwork must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_rwork) != NA_SFLOAT)
-    rblapack_rwork = na_change_type(rblapack_rwork, NA_SFLOAT);
-  rwork = NA_PTR_TYPE(rblapack_rwork, real*);
+  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*);
   if (!NA_IsNArray(rblapack_work))
     rb_raise(rb_eArgError, "work (6th argument) must be NArray");
   if (NA_RANK(rblapack_work) != 1)

data/ext/cla_syrfsx_extended.c

@@ -108,128 +108,128 @@ rblapack_cla_syrfsx_extended(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  rcond = (real)NUM2DBL(rblapack_rcond);
+  prec_type = NUM2INT(rblapack_prec_type);
+  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_SCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, complex*);
   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_b))
-    rb_raise(rb_eArgError, "b (8th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (8th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  nrhs = NA_SHAPE1(rblapack_b);
-  if (NA_TYPE(rblapack_b) != NA_SCOMPLEX)
-    rblapack_b = na_change_type(rblapack_b, NA_SCOMPLEX);
-  b = NA_PTR_TYPE(rblapack_b, complex*);
+  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_SFLOAT)
+    rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
+  c = NA_PTR_TYPE(rblapack_c, real*);
   if (!NA_IsNArray(rblapack_y))
     rb_raise(rb_eArgError, "y (9th argument) must be NArray");
   if (NA_RANK(rblapack_y) != 2)
     rb_raise(rb_eArgError, "rank of y (9th argument) must be %d", 2);
   ldy = NA_SHAPE0(rblapack_y);
-  if (NA_SHAPE1(rblapack_y) != nrhs)
-    rb_raise(rb_eRuntimeError, "shape 1 of y must be the same as shape 1 of b");
+  nrhs = NA_SHAPE1(rblapack_y);
   if (NA_TYPE(rblapack_y) != NA_SCOMPLEX)
     rblapack_y = na_change_type(rblapack_y, NA_SCOMPLEX);
   y = NA_PTR_TYPE(rblapack_y, complex*);
-  dz_ub = (real)NUM2DBL(rblapack_dz_ub);
-  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");
-  if (NA_TYPE(rblapack_af) != NA_SCOMPLEX)
-    rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
-  af = NA_PTR_TYPE(rblapack_af, complex*);
-  rthresh = (real)NUM2DBL(rblapack_rthresh);
-  if (!NA_IsNArray(rblapack_err_bnds_comp))
-    rb_raise(rb_eArgError, "err_bnds_comp (12th argument) must be NArray");
-  if (NA_RANK(rblapack_err_bnds_comp) != 2)
-    rb_raise(rb_eArgError, "rank of err_bnds_comp (12th argument) must be %d", 2);
-  if (NA_SHAPE0(rblapack_err_bnds_comp) != nrhs)
-    rb_raise(rb_eRuntimeError, "shape 0 of err_bnds_comp must be the same as shape 1 of b");
-  n_err_bnds = NA_SHAPE1(rblapack_err_bnds_comp);
-  if (NA_TYPE(rblapack_err_bnds_comp) != NA_SFLOAT)
-    rblapack_err_bnds_comp = na_change_type(rblapack_err_bnds_comp, NA_SFLOAT);
-  err_bnds_comp = NA_PTR_TYPE(rblapack_err_bnds_comp, real*);
-  if (!NA_IsNArray(rblapack_dy))
-    rb_raise(rb_eArgError, "dy (15th argument) must be NArray");
-  if (NA_RANK(rblapack_dy) != 1)
-    rb_raise(rb_eArgError, "rank of dy (15th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_dy) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of dy must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_dy) != NA_SCOMPLEX)
-    rblapack_dy = na_change_type(rblapack_dy, NA_SCOMPLEX);
-  dy = NA_PTR_TYPE(rblapack_dy, complex*);
   if (!NA_IsNArray(rblapack_err_bnds_norm))
     rb_raise(rb_eArgError, "err_bnds_norm (11th argument) must be NArray");
   if (NA_RANK(rblapack_err_bnds_norm) != 2)
     rb_raise(rb_eArgError, "rank of err_bnds_norm (11th argument) must be %d", 2);
   if (NA_SHAPE0(rblapack_err_bnds_norm) != nrhs)
-    rb_raise(rb_eRuntimeError, "shape 0 of err_bnds_norm must be the same as shape 1 of b");
-  if (NA_SHAPE1(rblapack_err_bnds_norm) != n_err_bnds)
-    rb_raise(rb_eRuntimeError, "shape 1 of err_bnds_norm must be the same as shape 1 of err_bnds_comp");
+    rb_raise(rb_eRuntimeError, "shape 0 of err_bnds_norm must be the same as shape 1 of y");
+  n_err_bnds = NA_SHAPE1(rblapack_err_bnds_norm);
   if (NA_TYPE(rblapack_err_bnds_norm) != NA_SFLOAT)
     rblapack_err_bnds_norm = na_change_type(rblapack_err_bnds_norm, NA_SFLOAT);
   err_bnds_norm = NA_PTR_TYPE(rblapack_err_bnds_norm, real*);
-  uplo = StringValueCStr(rblapack_uplo)[0];
   if (!NA_IsNArray(rblapack_res))
     rb_raise(rb_eArgError, "res (13th argument) must be NArray");
   if (NA_RANK(rblapack_res) != 1)
     rb_raise(rb_eArgError, "rank of res (13th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_res) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of res must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 0 of res must be the same as shape 1 of a");
   if (NA_TYPE(rblapack_res) != NA_SCOMPLEX)
     rblapack_res = na_change_type(rblapack_res, NA_SCOMPLEX);
   res = NA_PTR_TYPE(rblapack_res, complex*);
+  if (!NA_IsNArray(rblapack_dy))
+    rb_raise(rb_eArgError, "dy (15th argument) must be NArray");
+  if (NA_RANK(rblapack_dy) != 1)
+    rb_raise(rb_eArgError, "rank of dy (15th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_dy) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of dy must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_dy) != NA_SCOMPLEX)
+    rblapack_dy = na_change_type(rblapack_dy, NA_SCOMPLEX);
+  dy = NA_PTR_TYPE(rblapack_dy, complex*);
+  rcond = (real)NUM2DBL(rblapack_rcond);
+  rthresh = (real)NUM2DBL(rblapack_rthresh);
+  ignore_cwise = (rblapack_ignore_cwise == Qtrue);
+  uplo = StringValueCStr(rblapack_uplo)[0];
   colequ = (rblapack_colequ == Qtrue);
-  if (!NA_IsNArray(rblapack_y_tail))
-    rb_raise(rb_eArgError, "y_tail (16th argument) must be NArray");
-  if (NA_RANK(rblapack_y_tail) != 1)
-    rb_raise(rb_eArgError, "rank of y_tail (16th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_y_tail) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of y_tail must be the same as shape 0 of ipiv");
-  if (NA_TYPE(rblapack_y_tail) != NA_SCOMPLEX)
-    rblapack_y_tail = na_change_type(rblapack_y_tail, NA_SCOMPLEX);
-  y_tail = NA_PTR_TYPE(rblapack_y_tail, complex*);
-  ithresh = NUM2INT(rblapack_ithresh);
+  n_norms = NUM2INT(rblapack_n_norms);
   if (!NA_IsNArray(rblapack_ayb))
     rb_raise(rb_eArgError, "ayb (14th argument) must be NArray");
   if (NA_RANK(rblapack_ayb) != 1)
     rb_raise(rb_eArgError, "rank of ayb (14th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_ayb) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of ayb must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 0 of ayb must be the same as shape 1 of a");
   if (NA_TYPE(rblapack_ayb) != NA_SFLOAT)
     rblapack_ayb = na_change_type(rblapack_ayb, NA_SFLOAT);
   ayb = NA_PTR_TYPE(rblapack_ayb, real*);
-  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_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-  prec_type = NUM2INT(rblapack_prec_type);
-  n_norms = NUM2INT(rblapack_n_norms);
-  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_SFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, real*);
-  ignore_cwise = (rblapack_ignore_cwise == Qtrue);
+  ithresh = NUM2INT(rblapack_ithresh);
+  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 1 of a");
+  if (NA_TYPE(rblapack_af) != NA_SCOMPLEX)
+    rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
+  af = NA_PTR_TYPE(rblapack_af, complex*);
+  if (!NA_IsNArray(rblapack_err_bnds_comp))
+    rb_raise(rb_eArgError, "err_bnds_comp (12th argument) must be NArray");
+  if (NA_RANK(rblapack_err_bnds_comp) != 2)
+    rb_raise(rb_eArgError, "rank of err_bnds_comp (12th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_err_bnds_comp) != nrhs)
+    rb_raise(rb_eRuntimeError, "shape 0 of err_bnds_comp must be the same as shape 1 of y");
+  if (NA_SHAPE1(rblapack_err_bnds_comp) != n_err_bnds)
+    rb_raise(rb_eRuntimeError, "shape 1 of err_bnds_comp must be the same as shape 1 of err_bnds_norm");
+  if (NA_TYPE(rblapack_err_bnds_comp) != NA_SFLOAT)
+    rblapack_err_bnds_comp = na_change_type(rblapack_err_bnds_comp, NA_SFLOAT);
+  err_bnds_comp = NA_PTR_TYPE(rblapack_err_bnds_comp, real*);
+  dz_ub = (real)NUM2DBL(rblapack_dz_ub);
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (8th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (8th 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 y");
+  if (NA_TYPE(rblapack_b) != NA_SCOMPLEX)
+    rblapack_b = na_change_type(rblapack_b, NA_SCOMPLEX);
+  b = NA_PTR_TYPE(rblapack_b, complex*);
+  if (!NA_IsNArray(rblapack_y_tail))
+    rb_raise(rb_eArgError, "y_tail (16th argument) must be NArray");
+  if (NA_RANK(rblapack_y_tail) != 1)
+    rb_raise(rb_eArgError, "rank of y_tail (16th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_y_tail) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of y_tail must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_y_tail) != NA_SCOMPLEX)
+    rblapack_y_tail = na_change_type(rblapack_y_tail, NA_SCOMPLEX);
+  y_tail = NA_PTR_TYPE(rblapack_y_tail, complex*);
   {
     int shape[1];
     shape[0] = nrhs;

data/ext/cla_syrpvgrw.c

@@ -51,35 +51,36 @@ rblapack_cla_syrpvgrw(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  uplo = StringValueCStr(rblapack_uplo)[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_SCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, complex*);
   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*);
+  info = NUM2INT(rblapack_info);
   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_SCOMPLEX)
     rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
   af = NA_PTR_TYPE(rblapack_af, complex*);
-  uplo = StringValueCStr(rblapack_uplo)[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_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
   if (!NA_IsNArray(rblapack_work))
     rb_raise(rb_eArgError, "work (6th argument) must be NArray");
   if (NA_RANK(rblapack_work) != 1)
@@ -89,7 +90,6 @@ rblapack_cla_syrpvgrw(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_work) != NA_SCOMPLEX)
     rblapack_work = na_change_type(rblapack_work, NA_SCOMPLEX);
   work = NA_PTR_TYPE(rblapack_work, complex*);
-  info = NUM2INT(rblapack_info);
 
   __out__ = cla_syrpvgrw_(&uplo, &n, &info, a, &lda, af, &ldaf, ipiv, work);
 

data/ext/cla_wwaddw.c

@@ -42,11 +42,20 @@ rblapack_cla_wwaddw(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  if (!NA_IsNArray(rblapack_x))
+    rb_raise(rb_eArgError, "x (1th argument) must be NArray");
+  if (NA_RANK(rblapack_x) != 1)
+    rb_raise(rb_eArgError, "rank of x (1th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_x);
+  if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
+    rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
+  x = NA_PTR_TYPE(rblapack_x, complex*);
   if (!NA_IsNArray(rblapack_w))
     rb_raise(rb_eArgError, "w (3th argument) must be NArray");
   if (NA_RANK(rblapack_w) != 1)
     rb_raise(rb_eArgError, "rank of w (3th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_w);
+  if (NA_SHAPE0(rblapack_w) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of x");
   if (NA_TYPE(rblapack_w) != NA_SCOMPLEX)
     rblapack_w = na_change_type(rblapack_w, NA_SCOMPLEX);
   w = NA_PTR_TYPE(rblapack_w, complex*);
@@ -55,19 +64,10 @@ rblapack_cla_wwaddw(int argc, VALUE *argv, VALUE self){
   if (NA_RANK(rblapack_y) != 1)
     rb_raise(rb_eArgError, "rank of y (2th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_y) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of y must be the same as shape 0 of w");
+    rb_raise(rb_eRuntimeError, "shape 0 of y must be the same as shape 0 of x");
   if (NA_TYPE(rblapack_y) != NA_SCOMPLEX)
     rblapack_y = na_change_type(rblapack_y, NA_SCOMPLEX);
   y = NA_PTR_TYPE(rblapack_y, complex*);
-  if (!NA_IsNArray(rblapack_x))
-    rb_raise(rb_eArgError, "x (1th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 1)
-    rb_raise(rb_eArgError, "rank of x (1th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_x) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of x must be the same as shape 0 of w");
-  if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, complex*);
   {
     int shape[1];
     shape[0] = n;