ruby-lapack 1.4.1a → 1.5

data/ext/slarfx.c

@@ -46,6 +46,8 @@ rblapack_slarfx(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  side = StringValueCStr(rblapack_side)[0];
+  tau = (real)NUM2DBL(rblapack_tau);
   if (!NA_IsNArray(rblapack_v))
     rb_raise(rb_eArgError, "v (2th argument) must be NArray");
   if (NA_RANK(rblapack_v) != 1)
@@ -63,8 +65,6 @@ rblapack_slarfx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_c) != NA_SFLOAT)
     rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
   c = NA_PTR_TYPE(rblapack_c, real*);
-  side = StringValueCStr(rblapack_side)[0];
-  tau = (real)NUM2DBL(rblapack_tau);
   {
     int shape[2];
     shape[0] = ldc;

data/ext/slargv.c

@@ -53,8 +53,8 @@ rblapack_slargv(int argc, VALUE *argv, VALUE self){
   }
 
   n = NUM2INT(rblapack_n);
-  incc = NUM2INT(rblapack_incc);
   incx = NUM2INT(rblapack_incx);
+  incy = NUM2INT(rblapack_incy);
   if (!NA_IsNArray(rblapack_x))
     rb_raise(rb_eArgError, "x (2th argument) must be NArray");
   if (NA_RANK(rblapack_x) != 1)
@@ -64,7 +64,7 @@ rblapack_slargv(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_x) != NA_SFLOAT)
     rblapack_x = na_change_type(rblapack_x, NA_SFLOAT);
   x = NA_PTR_TYPE(rblapack_x, real*);
-  incy = NUM2INT(rblapack_incy);
+  incc = NUM2INT(rblapack_incc);
   if (!NA_IsNArray(rblapack_y))
     rb_raise(rb_eArgError, "y (4th argument) must be NArray");
   if (NA_RANK(rblapack_y) != 1)

data/ext/slarnv.c

@@ -41,6 +41,7 @@ rblapack_slarnv(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  idist = NUM2INT(rblapack_idist);
   n = NUM2INT(rblapack_n);
   if (!NA_IsNArray(rblapack_iseed))
     rb_raise(rb_eArgError, "iseed (2th argument) must be NArray");
@@ -51,7 +52,6 @@ rblapack_slarnv(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_iseed) != NA_LINT)
     rblapack_iseed = na_change_type(rblapack_iseed, NA_LINT);
   iseed = NA_PTR_TYPE(rblapack_iseed, integer*);
-  idist = NUM2INT(rblapack_idist);
   {
     int shape[1];
     shape[0] = MAX(1,n);

data/ext/slarra.c

@@ -54,34 +54,34 @@ rblapack_slarra(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  tnrm = (real)NUM2DBL(rblapack_tnrm);
-  spltol = (real)NUM2DBL(rblapack_spltol);
-  if (!NA_IsNArray(rblapack_e))
-    rb_raise(rb_eArgError, "e (2th argument) must be NArray");
-  if (NA_RANK(rblapack_e) != 1)
-    rb_raise(rb_eArgError, "rank of e (2th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_e);
-  if (NA_TYPE(rblapack_e) != NA_SFLOAT)
-    rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
-  e = NA_PTR_TYPE(rblapack_e, real*);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (1th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (1th 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_e2))
     rb_raise(rb_eArgError, "e2 (3th argument) must be NArray");
   if (NA_RANK(rblapack_e2) != 1)
     rb_raise(rb_eArgError, "rank of e2 (3th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_e2) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of e2 must be the same as shape 0 of e");
+    rb_raise(rb_eRuntimeError, "shape 0 of e2 must be the same as shape 0 of d");
   if (NA_TYPE(rblapack_e2) != NA_SFLOAT)
     rblapack_e2 = na_change_type(rblapack_e2, NA_SFLOAT);
   e2 = NA_PTR_TYPE(rblapack_e2, real*);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (1th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (1th 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 0 of e");
-  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
-    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
-  d = NA_PTR_TYPE(rblapack_d, real*);
+  tnrm = (real)NUM2DBL(rblapack_tnrm);
+  if (!NA_IsNArray(rblapack_e))
+    rb_raise(rb_eArgError, "e (2th argument) must be NArray");
+  if (NA_RANK(rblapack_e) != 1)
+    rb_raise(rb_eArgError, "rank of e (2th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_e) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of e must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_e) != NA_SFLOAT)
+    rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
+  e = NA_PTR_TYPE(rblapack_e, real*);
+  spltol = (real)NUM2DBL(rblapack_spltol);
   {
     int shape[1];
     shape[0] = n;

data/ext/slarrb.c

@@ -78,8 +78,6 @@ rblapack_slarrb(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  ilast = NUM2INT(rblapack_ilast);
-  spdiam = (real)NUM2DBL(rblapack_spdiam);
   if (!NA_IsNArray(rblapack_d))
     rb_raise(rb_eArgError, "d (1th argument) must be NArray");
   if (NA_RANK(rblapack_d) != 1)
@@ -88,18 +86,9 @@ rblapack_slarrb(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_d) != NA_SFLOAT)
     rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
   d = NA_PTR_TYPE(rblapack_d, real*);
-  twist = NUM2INT(rblapack_twist);
   ifirst = NUM2INT(rblapack_ifirst);
+  rtol1 = (real)NUM2DBL(rblapack_rtol1);
   offset = NUM2INT(rblapack_offset);
-  if (!NA_IsNArray(rblapack_w))
-    rb_raise(rb_eArgError, "w (8th argument) must be NArray");
-  if (NA_RANK(rblapack_w) != 1)
-    rb_raise(rb_eArgError, "rank of w (8th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_w) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of d");
-  if (NA_TYPE(rblapack_w) != NA_SFLOAT)
-    rblapack_w = na_change_type(rblapack_w, NA_SFLOAT);
-  w = NA_PTR_TYPE(rblapack_w, real*);
   if (!NA_IsNArray(rblapack_werr))
     rb_raise(rb_eArgError, "werr (10th argument) must be NArray");
   if (NA_RANK(rblapack_werr) != 1)
@@ -109,17 +98,18 @@ rblapack_slarrb(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_werr) != NA_SFLOAT)
     rblapack_werr = na_change_type(rblapack_werr, NA_SFLOAT);
   werr = NA_PTR_TYPE(rblapack_werr, real*);
+  spdiam = (real)NUM2DBL(rblapack_spdiam);
+  ilast = NUM2INT(rblapack_ilast);
+  if (!NA_IsNArray(rblapack_w))
+    rb_raise(rb_eArgError, "w (8th argument) must be NArray");
+  if (NA_RANK(rblapack_w) != 1)
+    rb_raise(rb_eArgError, "rank of w (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_w) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_w) != NA_SFLOAT)
+    rblapack_w = na_change_type(rblapack_w, NA_SFLOAT);
+  w = NA_PTR_TYPE(rblapack_w, real*);
   pivmin = (real)NUM2DBL(rblapack_pivmin);
-  if (!NA_IsNArray(rblapack_wgap))
-    rb_raise(rb_eArgError, "wgap (9th argument) must be NArray");
-  if (NA_RANK(rblapack_wgap) != 1)
-    rb_raise(rb_eArgError, "rank of wgap (9th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_wgap) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of wgap must be %d", n-1);
-  if (NA_TYPE(rblapack_wgap) != NA_SFLOAT)
-    rblapack_wgap = na_change_type(rblapack_wgap, NA_SFLOAT);
-  wgap = NA_PTR_TYPE(rblapack_wgap, real*);
-  rtol1 = (real)NUM2DBL(rblapack_rtol1);
   if (!NA_IsNArray(rblapack_lld))
     rb_raise(rb_eArgError, "lld (2th argument) must be NArray");
   if (NA_RANK(rblapack_lld) != 1)
@@ -129,7 +119,17 @@ rblapack_slarrb(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_lld) != NA_SFLOAT)
     rblapack_lld = na_change_type(rblapack_lld, NA_SFLOAT);
   lld = NA_PTR_TYPE(rblapack_lld, real*);
+  if (!NA_IsNArray(rblapack_wgap))
+    rb_raise(rb_eArgError, "wgap (9th argument) must be NArray");
+  if (NA_RANK(rblapack_wgap) != 1)
+    rb_raise(rb_eArgError, "rank of wgap (9th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_wgap) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of wgap must be %d", n-1);
+  if (NA_TYPE(rblapack_wgap) != NA_SFLOAT)
+    rblapack_wgap = na_change_type(rblapack_wgap, NA_SFLOAT);
+  wgap = NA_PTR_TYPE(rblapack_wgap, real*);
   rtol2 = (real)NUM2DBL(rblapack_rtol2);
+  twist = NUM2INT(rblapack_twist);
   {
     int shape[1];
     shape[0] = n;

data/ext/slarrc.c

@@ -55,27 +55,27 @@ rblapack_slarrc(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  vl = (real)NUM2DBL(rblapack_vl);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (4th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (4th 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*);
-  vu = (real)NUM2DBL(rblapack_vu);
   jobt = StringValueCStr(rblapack_jobt)[0];
-  pivmin = (real)NUM2DBL(rblapack_pivmin);
+  vu = (real)NUM2DBL(rblapack_vu);
   if (!NA_IsNArray(rblapack_e))
     rb_raise(rb_eArgError, "e (5th argument) must be NArray");
   if (NA_RANK(rblapack_e) != 1)
     rb_raise(rb_eArgError, "rank of e (5th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_e) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of e must be the same as shape 0 of d");
+  n = NA_SHAPE0(rblapack_e);
   if (NA_TYPE(rblapack_e) != NA_SFLOAT)
     rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
   e = NA_PTR_TYPE(rblapack_e, real*);
+  vl = (real)NUM2DBL(rblapack_vl);
+  pivmin = (real)NUM2DBL(rblapack_pivmin);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (4th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (4th 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 0 of e");
+  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
+    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
+  d = NA_PTR_TYPE(rblapack_d, real*);
 
   slarrc_(&jobt, &n, &vl, &vu, d, e, &pivmin, &eigcnt, &lcnt, &rcnt, &info);
 

data/ext/slarrd.c

@@ -89,30 +89,30 @@ rblapack_slarrd(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  vl = (real)NUM2DBL(rblapack_vl);
-  nsplit = NUM2INT(rblapack_nsplit);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (9th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (9th 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*);
-  order = StringValueCStr(rblapack_order)[0];
   range = StringValueCStr(rblapack_range)[0];
-  pivmin = (real)NUM2DBL(rblapack_pivmin);
-  iu = NUM2INT(rblapack_iu);
+  vl = (real)NUM2DBL(rblapack_vl);
   il = NUM2INT(rblapack_il);
+  reltol = (real)NUM2DBL(rblapack_reltol);
+  pivmin = (real)NUM2DBL(rblapack_pivmin);
   if (!NA_IsNArray(rblapack_isplit))
     rb_raise(rb_eArgError, "isplit (14th argument) must be NArray");
   if (NA_RANK(rblapack_isplit) != 1)
     rb_raise(rb_eArgError, "rank of isplit (14th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_isplit) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of isplit must be the same as shape 0 of d");
+  n = NA_SHAPE0(rblapack_isplit);
   if (NA_TYPE(rblapack_isplit) != NA_LINT)
     rblapack_isplit = na_change_type(rblapack_isplit, NA_LINT);
   isplit = NA_PTR_TYPE(rblapack_isplit, integer*);
+  order = StringValueCStr(rblapack_order)[0];
+  iu = NUM2INT(rblapack_iu);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (9th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (9th 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 0 of isplit");
+  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_e2))
     rb_raise(rb_eArgError, "e2 (11th argument) must be NArray");
   if (NA_RANK(rblapack_e2) != 1)
@@ -122,17 +122,7 @@ rblapack_slarrd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_e2) != NA_SFLOAT)
     rblapack_e2 = na_change_type(rblapack_e2, NA_SFLOAT);
   e2 = NA_PTR_TYPE(rblapack_e2, real*);
-  reltol = (real)NUM2DBL(rblapack_reltol);
   vu = (real)NUM2DBL(rblapack_vu);
-  if (!NA_IsNArray(rblapack_gers))
-    rb_raise(rb_eArgError, "gers (7th argument) must be NArray");
-  if (NA_RANK(rblapack_gers) != 1)
-    rb_raise(rb_eArgError, "rank of gers (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_gers) != (2*n))
-    rb_raise(rb_eRuntimeError, "shape 0 of gers must be %d", 2*n);
-  if (NA_TYPE(rblapack_gers) != NA_SFLOAT)
-    rblapack_gers = na_change_type(rblapack_gers, NA_SFLOAT);
-  gers = NA_PTR_TYPE(rblapack_gers, real*);
   if (!NA_IsNArray(rblapack_e))
     rb_raise(rb_eArgError, "e (10th argument) must be NArray");
   if (NA_RANK(rblapack_e) != 1)
@@ -142,6 +132,16 @@ rblapack_slarrd(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*);
+  if (!NA_IsNArray(rblapack_gers))
+    rb_raise(rb_eArgError, "gers (7th argument) must be NArray");
+  if (NA_RANK(rblapack_gers) != 1)
+    rb_raise(rb_eArgError, "rank of gers (7th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_gers) != (2*n))
+    rb_raise(rb_eRuntimeError, "shape 0 of gers must be %d", 2*n);
+  if (NA_TYPE(rblapack_gers) != NA_SFLOAT)
+    rblapack_gers = na_change_type(rblapack_gers, NA_SFLOAT);
+  gers = NA_PTR_TYPE(rblapack_gers, real*);
+  nsplit = NUM2INT(rblapack_nsplit);
   {
     int shape[1];
     shape[0] = n;

data/ext/slarre.c

@@ -92,40 +92,40 @@ rblapack_slarre(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  vl = (real)NUM2DBL(rblapack_vl);
-  if (!NA_IsNArray(rblapack_e2))
-    rb_raise(rb_eArgError, "e2 (8th argument) must be NArray");
-  if (NA_RANK(rblapack_e2) != 1)
-    rb_raise(rb_eArgError, "rank of e2 (8th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_e2);
-  if (NA_TYPE(rblapack_e2) != NA_SFLOAT)
-    rblapack_e2 = na_change_type(rblapack_e2, NA_SFLOAT);
-  e2 = NA_PTR_TYPE(rblapack_e2, real*);
-  spltol = (real)NUM2DBL(rblapack_spltol);
+  range = StringValueCStr(rblapack_range)[0];
+  vu = (real)NUM2DBL(rblapack_vu);
+  iu = NUM2INT(rblapack_iu);
   if (!NA_IsNArray(rblapack_e))
     rb_raise(rb_eArgError, "e (7th argument) must be NArray");
   if (NA_RANK(rblapack_e) != 1)
     rb_raise(rb_eArgError, "rank of e (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_e) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of e must be the same as shape 0 of e2");
+  n = NA_SHAPE0(rblapack_e);
   if (NA_TYPE(rblapack_e) != NA_SFLOAT)
     rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
   e = NA_PTR_TYPE(rblapack_e, real*);
   rtol1 = (real)NUM2DBL(rblapack_rtol1);
-  rtol2 = (real)NUM2DBL(rblapack_rtol2);
-  iu = NUM2INT(rblapack_iu);
+  spltol = (real)NUM2DBL(rblapack_spltol);
+  vl = (real)NUM2DBL(rblapack_vl);
   if (!NA_IsNArray(rblapack_d))
     rb_raise(rb_eArgError, "d (6th argument) must be NArray");
   if (NA_RANK(rblapack_d) != 1)
     rb_raise(rb_eArgError, "rank of d (6th 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 0 of e2");
+    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 0 of e");
   if (NA_TYPE(rblapack_d) != NA_SFLOAT)
     rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
   d = NA_PTR_TYPE(rblapack_d, real*);
-  vu = (real)NUM2DBL(rblapack_vu);
+  rtol2 = (real)NUM2DBL(rblapack_rtol2);
   il = NUM2INT(rblapack_il);
-  range = StringValueCStr(rblapack_range)[0];
+  if (!NA_IsNArray(rblapack_e2))
+    rb_raise(rb_eArgError, "e2 (8th argument) must be NArray");
+  if (NA_RANK(rblapack_e2) != 1)
+    rb_raise(rb_eArgError, "rank of e2 (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_e2) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of e2 must be the same as shape 0 of e");
+  if (NA_TYPE(rblapack_e2) != NA_SFLOAT)
+    rblapack_e2 = na_change_type(rblapack_e2, NA_SFLOAT);
+  e2 = NA_PTR_TYPE(rblapack_e2, real*);
   {
     int shape[1];
     shape[0] = n;

data/ext/slarrf.c

@@ -76,7 +76,6 @@ rblapack_slarrf(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  spdiam = (real)NUM2DBL(rblapack_spdiam);
   if (!NA_IsNArray(rblapack_d))
     rb_raise(rb_eArgError, "d (1th argument) must be NArray");
   if (NA_RANK(rblapack_d) != 1)
@@ -85,17 +84,6 @@ rblapack_slarrf(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_d) != NA_SFLOAT)
     rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
   d = NA_PTR_TYPE(rblapack_d, real*);
-  clend = NUM2INT(rblapack_clend);
-  pivmin = (real)NUM2DBL(rblapack_pivmin);
-  if (!NA_IsNArray(rblapack_l))
-    rb_raise(rb_eArgError, "l (2th argument) must be NArray");
-  if (NA_RANK(rblapack_l) != 1)
-    rb_raise(rb_eArgError, "rank of l (2th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_l) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of l must be %d", n-1);
-  if (NA_TYPE(rblapack_l) != NA_SFLOAT)
-    rblapack_l = na_change_type(rblapack_l, NA_SFLOAT);
-  l = NA_PTR_TYPE(rblapack_l, real*);
   if (!NA_IsNArray(rblapack_ld))
     rb_raise(rb_eArgError, "ld (3th argument) must be NArray");
   if (NA_RANK(rblapack_ld) != 1)
@@ -105,9 +93,30 @@ rblapack_slarrf(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_ld) != NA_SFLOAT)
     rblapack_ld = na_change_type(rblapack_ld, NA_SFLOAT);
   ld = NA_PTR_TYPE(rblapack_ld, real*);
+  clend = NUM2INT(rblapack_clend);
+  spdiam = (real)NUM2DBL(rblapack_spdiam);
   clgapr = (real)NUM2DBL(rblapack_clgapr);
+  if (!NA_IsNArray(rblapack_l))
+    rb_raise(rb_eArgError, "l (2th argument) must be NArray");
+  if (NA_RANK(rblapack_l) != 1)
+    rb_raise(rb_eArgError, "rank of l (2th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_l) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of l must be %d", n-1);
+  if (NA_TYPE(rblapack_l) != NA_SFLOAT)
+    rblapack_l = na_change_type(rblapack_l, NA_SFLOAT);
+  l = NA_PTR_TYPE(rblapack_l, real*);
   clgapl = (real)NUM2DBL(rblapack_clgapl);
   clstrt = NUM2INT(rblapack_clstrt);
+  if (!NA_IsNArray(rblapack_wgap))
+    rb_raise(rb_eArgError, "wgap (7th argument) must be NArray");
+  if (NA_RANK(rblapack_wgap) != 1)
+    rb_raise(rb_eArgError, "rank of wgap (7th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_wgap) != (clend-clstrt+1))
+    rb_raise(rb_eRuntimeError, "shape 0 of wgap must be %d", clend-clstrt+1);
+  if (NA_TYPE(rblapack_wgap) != NA_SFLOAT)
+    rblapack_wgap = na_change_type(rblapack_wgap, NA_SFLOAT);
+  wgap = NA_PTR_TYPE(rblapack_wgap, real*);
+  pivmin = (real)NUM2DBL(rblapack_pivmin);
   if (!NA_IsNArray(rblapack_w))
     rb_raise(rb_eArgError, "w (6th argument) must be NArray");
   if (NA_RANK(rblapack_w) != 1)
@@ -126,15 +135,6 @@ rblapack_slarrf(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_werr) != NA_SFLOAT)
     rblapack_werr = na_change_type(rblapack_werr, NA_SFLOAT);
   werr = NA_PTR_TYPE(rblapack_werr, real*);
-  if (!NA_IsNArray(rblapack_wgap))
-    rb_raise(rb_eArgError, "wgap (7th argument) must be NArray");
-  if (NA_RANK(rblapack_wgap) != 1)
-    rb_raise(rb_eArgError, "rank of wgap (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_wgap) != (clend-clstrt+1))
-    rb_raise(rb_eRuntimeError, "shape 0 of wgap must be %d", clend-clstrt+1);
-  if (NA_TYPE(rblapack_wgap) != NA_SFLOAT)
-    rblapack_wgap = na_change_type(rblapack_wgap, NA_SFLOAT);
-  wgap = NA_PTR_TYPE(rblapack_wgap, real*);
   {
     int shape[1];
     shape[0] = n;

data/ext/slarrj.c

@@ -67,37 +67,36 @@ rblapack_slarrj(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  ilast = NUM2INT(rblapack_ilast);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (1th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (1th 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*);
+  ifirst = NUM2INT(rblapack_ifirst);
   rtol = (real)NUM2DBL(rblapack_rtol);
-  spdiam = (real)NUM2DBL(rblapack_spdiam);
-  if (!NA_IsNArray(rblapack_werr))
-    rb_raise(rb_eArgError, "werr (8th argument) must be NArray");
-  if (NA_RANK(rblapack_werr) != 1)
-    rb_raise(rb_eArgError, "rank of werr (8th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_werr);
-  if (NA_TYPE(rblapack_werr) != NA_SFLOAT)
-    rblapack_werr = na_change_type(rblapack_werr, NA_SFLOAT);
-  werr = NA_PTR_TYPE(rblapack_werr, real*);
-  pivmin = (real)NUM2DBL(rblapack_pivmin);
   if (!NA_IsNArray(rblapack_w))
     rb_raise(rb_eArgError, "w (7th argument) must be NArray");
   if (NA_RANK(rblapack_w) != 1)
     rb_raise(rb_eArgError, "rank of w (7th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_w) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of werr");
+    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of d");
   if (NA_TYPE(rblapack_w) != NA_SFLOAT)
     rblapack_w = na_change_type(rblapack_w, NA_SFLOAT);
   w = NA_PTR_TYPE(rblapack_w, real*);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (1th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (1th 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 0 of werr");
-  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
-    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
-  d = NA_PTR_TYPE(rblapack_d, real*);
-  offset = NUM2INT(rblapack_offset);
+  pivmin = (real)NUM2DBL(rblapack_pivmin);
+  ilast = NUM2INT(rblapack_ilast);
+  if (!NA_IsNArray(rblapack_werr))
+    rb_raise(rb_eArgError, "werr (8th argument) must be NArray");
+  if (NA_RANK(rblapack_werr) != 1)
+    rb_raise(rb_eArgError, "rank of werr (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_werr) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of werr must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_werr) != NA_SFLOAT)
+    rblapack_werr = na_change_type(rblapack_werr, NA_SFLOAT);
+  werr = NA_PTR_TYPE(rblapack_werr, real*);
   if (!NA_IsNArray(rblapack_e2))
     rb_raise(rb_eArgError, "e2 (2th argument) must be NArray");
   if (NA_RANK(rblapack_e2) != 1)
@@ -107,7 +106,8 @@ rblapack_slarrj(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_e2) != NA_SFLOAT)
     rblapack_e2 = na_change_type(rblapack_e2, NA_SFLOAT);
   e2 = NA_PTR_TYPE(rblapack_e2, real*);
-  ifirst = NUM2INT(rblapack_ifirst);
+  spdiam = (real)NUM2DBL(rblapack_spdiam);
+  offset = NUM2INT(rblapack_offset);
   {
     int shape[1];
     shape[0] = n;