gsl 1.15.3 → 1.16.0.6

data/ext/{linalg.c → gsl_native/linalg.c}

@@ -9,11 +9,10 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_config.h"
 #include <gsl/gsl_math.h>
-#include "rb_gsl_array.h"
-#include "rb_gsl_common.h"
-#include "rb_gsl_linalg.h"
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_common.h"
+#include "include/rb_gsl_linalg.h"
 
 static VALUE cgsl_matrix_LU;
 static VALUE cgsl_matrix_QR;
@@ -39,7 +38,40 @@ enum {
 
 #ifdef HAVE_NARRAY_H
 static VALUE rb_gsl_linalg_LU_decomp_narray(int argc, VALUE *argv, VALUE obj,
-					    int flag);
+                                            int flag)
+{
+  struct NARRAY *na, *na2;
+  VALUE m;
+  gsl_matrix_view mv;
+  gsl_permutation *p;
+  int signum;
+
+  if (argc != 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+  GetNArray(argv[0], na);
+  if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required");
+  if (na->shape[0] != na->shape[1])
+    rb_raise(rb_eRuntimeError, "square matrix required");
+  if (flag == LINALG_DECOMP) {
+    m = na_make_object(NA_DFLOAT, 2, na->shape, CLASS_OF(argv[0]));
+    GetNArray(m, na2);
+    memcpy((double*)na2->ptr, (double*)na->ptr, sizeof(double)*na2->total);
+    mv = gsl_matrix_view_array((double*)na2->ptr, na->shape[1], na->shape[0]);
+  } else {
+    mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]);
+  }
+  p = gsl_permutation_alloc(mv.matrix.size1);
+  gsl_linalg_LU_decomp(&mv.matrix, p, &signum);
+  if (flag == LINALG_DECOMP) {
+    return rb_ary_new3(3, m,
+                       Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p),
+                       INT2FIX(signum));
+  } else {
+    return rb_ary_new3(3, argv[0],
+                       Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p),
+                       INT2FIX(signum));
+  }
+}
 #endif
 
 static VALUE rb_gsl_linalg_LU_decomposition(int argc, VALUE *argv, VALUE obj, int flag)
@@ -52,7 +84,7 @@ static VALUE rb_gsl_linalg_LU_decomposition(int argc, VALUE *argv, VALUE obj, in
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
 #ifdef HAVE_NARRAY_H
-    if (NA_IsNArray(argv[0])) 
+    if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_LU_decomp_narray(argc, argv, obj, flag);
 #endif
     if (MATRIX_COMPLEX_P(argv[0]))
@@ -71,7 +103,7 @@ static VALUE rb_gsl_linalg_LU_decomposition(int argc, VALUE *argv, VALUE obj, in
   Data_Get_Struct(omatrix, gsl_matrix, mtmp);
   if (flag == LINALG_DECOMP_BANG) {
     m = mtmp;
-    RBASIC(omatrix)->klass = cgsl_matrix_LU;
+    RBGSL_SET_CLASS(omatrix, cgsl_matrix_LU);
     objm = omatrix;
   } else {
     m = make_matrix_clone(mtmp);
@@ -110,45 +142,6 @@ static VALUE rb_gsl_linalg_LU_decomp_bang(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_LU_decomposition(argc, argv, obj, LINALG_DECOMP_BANG);
 }
 
-#ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_LU_decomp_narray(int argc, VALUE *argv, VALUE obj,
-					    int flag)
-{
-  struct NARRAY *na, *na2;
-  VALUE m;
-  gsl_matrix_view mv;
-  gsl_permutation *p;
-  int signum;
-
-  if (argc != 1) 
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
-  GetNArray(argv[0], na);
-  if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required");
-  if (na->shape[0] != na->shape[1])
-    rb_raise(rb_eRuntimeError, "square matrix required");
-  if (flag == LINALG_DECOMP) {
-    m = na_make_object(NA_DFLOAT, 2, na->shape, CLASS_OF(argv[0]));
-    GetNArray(m, na2);
-    memcpy((double*)na2->ptr, (double*)na->ptr, sizeof(double)*na2->total);
-    mv = gsl_matrix_view_array((double*)na2->ptr, na->shape[1], na->shape[0]);
-  } else {
-    mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]);
-  }
-  p = gsl_permutation_alloc(mv.matrix.size1);
-  gsl_linalg_LU_decomp(&mv.matrix, p, &signum);
-  if (flag == LINALG_DECOMP) {
-    return rb_ary_new3(3, m, 
-		       Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p),
-		       INT2FIX(signum));
-  } else {
-    return rb_ary_new3(3, argv[0], 
-		Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p),
-		INT2FIX(signum));
-  }
-  
-}
-#endif
-
 static gsl_matrix* get_matrix(VALUE obj, VALUE klass,int *flagm);
 static gsl_permutation* get_permutation(VALUE obj,  size_t size, int *flagp);
 static gsl_vector* get_vector2(VALUE obj,  int *flagv);
@@ -156,15 +149,13 @@ static gsl_vector* get_vector2(VALUE obj,  int *flagv);
 static gsl_matrix* get_matrix(VALUE obj, VALUE klass, int *flagm)
 {
   gsl_matrix *mtmp = NULL, *m = NULL;
-#ifdef HAVE_NARRAY_H
-  gsl_matrix_view mv;
-  struct NARRAY *na;
-#endif
   if (CLASS_OF(obj) == klass) {
     Data_Get_Struct(obj, gsl_matrix, m);
     *flagm = 0;
 #ifdef HAVE_NARRAY_H
   } else if (NA_IsNArray(obj)) {
+    gsl_matrix_view mv;
+    struct NARRAY *na;
     GetNArray(obj, na);
     mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]);
     m = &mv.matrix;
@@ -195,15 +186,13 @@ static gsl_permutation* get_permutation(VALUE obj, size_t size, int *flagp)
 static gsl_vector* get_vector2(VALUE obj, int *flagv)
 {
   gsl_vector *v = NULL;
-#ifdef HAVE_NARRAY_H
-  gsl_vector_view vv;
-  struct NARRAY *na;
-#endif
   if (TYPE(obj) == T_ARRAY) {
     v = make_cvector_from_rarray(obj);
     *flagv = 1;
 #ifdef HAVE_NARRAY_H
   } else if (NA_IsNArray(obj)) {
+    gsl_vector_view vv;
+    struct NARRAY *na;
     GetNArray(obj, na);
     vv = gsl_vector_view_array((double*) na->ptr, na->total);
     v = &vv.vector;
@@ -218,7 +207,36 @@ static gsl_vector* get_vector2(VALUE obj, int *flagv)
 }
 
 #ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_LU_solve_narray(int argc, VALUE *argv, VALUE obj);
+static VALUE rb_gsl_linalg_LU_solve_narray(int argc, VALUE *argv, VALUE obj)
+{
+  struct NARRAY *na, *b;
+  VALUE ret;
+  gsl_permutation *p;
+  gsl_matrix_view mv;
+  gsl_vector_view bv, xv;
+  double *x;
+  int shape[1];
+  if (argc < 3)
+    rb_raise(rb_eArgError,
+             "wrong number of arguments %d(NArray, GSL::Permutation and NArray expected",
+             argc);
+  GetNArray(argv[0], na);
+  mv = gsl_matrix_view_array((double*) na->ptr, na->shape[1], na->shape[0]);
+  CHECK_PERMUTATION(argv[1]);
+  Data_Get_Struct(argv[1], gsl_permutation, p);
+  GetNArray(argv[2], b);
+  bv = gsl_vector_view_array((double*) b->ptr, b->total);
+  if (argc == 3) {
+    shape[0] = b->total;
+    ret = na_make_object(NA_DFLOAT, 1, shape, CLASS_OF(argv[0]));
+  } else {
+    ret = argv[3];
+  }
+  x = NA_PTR_TYPE(ret,double*);
+  xv = gsl_vector_view_array(x, b->total);
+  gsl_linalg_LU_solve(&mv.matrix, p, &bv.vector, &xv.vector);
+  return ret;
+}
 #endif
 
 VALUE rb_gsl_linalg_LU_solve(int argc, VALUE *argv, VALUE obj)
@@ -231,19 +249,18 @@ VALUE rb_gsl_linalg_LU_solve(int argc, VALUE *argv, VALUE obj)
   VALUE bb;
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
-    if (argc < 2 || argc > 4) 
+    if (argc < 2 || argc > 4)
       rb_raise(rb_eArgError, "Usage: solve(m, b), solve(m, b, x), solve(lu, p, b), solve(lu, p, b, x)");
 #ifdef HAVE_NARRAY_H
-    if (NA_IsNArray(argv[0])) 
+    if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_LU_solve_narray(argc, argv, obj);
 #endif
     m = get_matrix(argv[0], cgsl_matrix_LU, &flagm);
     itmp = 1;
     break;
   default:
-    if (argc < 1 || argc > 3) 
+    if (argc < 1 || argc > 3)
       rb_raise(rb_eArgError, "Usage: LU_solve(b), LU_solve(p, b), LU_solve(b, x), solve(p, b, x)");
-    
     m = get_matrix(obj, cgsl_matrix_LU, &flagm);
     itmp = 0;
     break;
@@ -253,7 +270,6 @@ VALUE rb_gsl_linalg_LU_solve(int argc, VALUE *argv, VALUE obj)
   p = get_permutation(argv[itmp], size, &flagp);
   if (flagp == 1 && flagm == 0) rb_raise(rb_eArgError, "permutation must be given");
   if (flagp == 0) itmp++;
-
   bb = argv[itmp];
   b = get_vector2(argv[itmp], &flagb);
   itmp++;
@@ -275,42 +291,27 @@ VALUE rb_gsl_linalg_LU_solve(int argc, VALUE *argv, VALUE obj)
 }
 
 #ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_LU_solve_narray(int argc, VALUE *argv, VALUE obj)
+static VALUE rb_gsl_linalg_LU_svx_narray(int argc, VALUE *argv, VALUE obj)
 {
   struct NARRAY *na, *b;
-  VALUE ret;
   gsl_permutation *p;
   gsl_matrix_view mv;
-  gsl_vector_view bv, xv;
-  double *x;
-  int shape[1];
-  if (argc < 3)
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments %d(NArray, GSL::Permutation and NArray expected", 
-	     argc);
+  gsl_vector_view bv;
+  if (argc != 3)
+    rb_raise(rb_eArgError,
+             "wrong number of arguments %d(NArray, GSL::Permutation and NArray expected",
+             argc);
   GetNArray(argv[0], na);
   mv = gsl_matrix_view_array((double*) na->ptr, na->shape[1], na->shape[0]);
   CHECK_PERMUTATION(argv[1]);
   Data_Get_Struct(argv[1], gsl_permutation, p);
   GetNArray(argv[2], b);
   bv = gsl_vector_view_array((double*) b->ptr, b->total);
-  if (argc == 3) {
-    shape[0] = b->total;
-    ret = na_make_object(NA_DFLOAT, 1, shape, CLASS_OF(argv[0]));
-  } else {
-    ret = argv[3];
-  }
-  x = NA_PTR_TYPE(ret,double*);
-  xv = gsl_vector_view_array(x, b->total);
-  gsl_linalg_LU_solve(&mv.matrix, p, &bv.vector, &xv.vector);
-  return ret;
+  gsl_linalg_LU_svx(&mv.matrix, p, &bv.vector);
+  return argv[2];
 }
 #endif
 
-#ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_LU_svx_narray(int argc, VALUE *argv, VALUE obj);
-#endif
-
 /* bb must be Vector, it is replaced by the root of the system */
 static VALUE rb_gsl_linalg_LU_svx(int argc, VALUE *argv, VALUE obj)
 {
@@ -322,18 +323,18 @@ static VALUE rb_gsl_linalg_LU_svx(int argc, VALUE *argv, VALUE obj)
 
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
-    if (argc < 2 || argc > 3) 
+    if (argc < 2 || argc > 3)
       rb_raise(rb_eArgError, "Usage: svx(m, b), svx(lu, p, b)");
 #ifdef HAVE_NARRAY_H
-  if (NA_IsNArray(argv[0])) 
-    return rb_gsl_linalg_LU_svx_narray(argc, argv, obj);
+    if (NA_IsNArray(argv[0]))
+      return rb_gsl_linalg_LU_svx_narray(argc, argv, obj);
 #endif
     m = get_matrix(argv[0], cgsl_matrix_LU, &flagm);
     itmp = 1;
     break;
   default:
-   if (argc < 1 || argc > 2) 
-     rb_raise(rb_eArgError, "Usage: LU_svx(b), LU_svx(p, b)");
+    if (argc < 1 || argc > 2)
+      rb_raise(rb_eArgError, "Usage: LU_svx(b), LU_svx(p, b)");
     m = get_matrix(obj, cgsl_matrix_LU, &flagm);
     itmp = 0;
     break;
@@ -351,32 +352,10 @@ static VALUE rb_gsl_linalg_LU_svx(int argc, VALUE *argv, VALUE obj)
   return argv[itmp];
 }
 
-#ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_LU_svx_narray(int argc, VALUE *argv, VALUE obj)
-{
-  struct NARRAY *na, *b;
-  gsl_permutation *p;
-  gsl_matrix_view mv;
-  gsl_vector_view bv;
-  if (argc != 3)
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments %d(NArray, GSL::Permutation and NArray expected", 
-	     argc);
-  GetNArray(argv[0], na);
-  mv = gsl_matrix_view_array((double*) na->ptr, na->shape[1], na->shape[0]);
-  CHECK_PERMUTATION(argv[1]);
-  Data_Get_Struct(argv[1], gsl_permutation, p);
-  GetNArray(argv[2], b);
-  bv = gsl_vector_view_array((double*) b->ptr, b->total);
-  gsl_linalg_LU_svx(&mv.matrix, p, &bv.vector);
-  return argv[2];
-}
-#endif
-
 /* singleton */
 static VALUE rb_gsl_linalg_LU_refine(VALUE obj, VALUE vm,
-				     VALUE lu, VALUE pp, VALUE bb,
-				     VALUE xx)
+                                     VALUE lu, VALUE pp, VALUE bb,
+                                     VALUE xx)
 {
   gsl_matrix *m = NULL, *mlu = NULL;
   gsl_permutation *p = NULL;
@@ -403,59 +382,6 @@ static VALUE rb_gsl_linalg_LU_refine(VALUE obj, VALUE vm,
   return rb_ary_new3(2, xx, vr);
 }
 
-#ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_LU_invert_narray(int argc, VALUE *argv, VALUE obj);
-#endif
-
-static VALUE rb_gsl_linalg_LU_invert(int argc, VALUE *argv, VALUE obj)
-{
-  gsl_matrix *m = NULL, *inverse = NULL;
-  gsl_permutation *p = NULL;
-  int signum, flagm = 0, flagp = 0, itmp;
-  size_t size;
-  switch (TYPE(obj)) {
-  case T_MODULE:  case T_CLASS:  case T_OBJECT:
-#ifdef HAVE_NARRAY_H
-    if (NA_IsNArray(argv[0]))
-      return rb_gsl_linalg_LU_invert_narray(argc, argv, obj);
-#endif
-    m = get_matrix(argv[0], cgsl_matrix_LU, &flagm);
-    itmp = 1;
-    break;
-  default:
-    m = get_matrix(obj, cgsl_matrix_LU, &flagm);
-    itmp = 0;
-  }
-  size = m->size1;
-
-  if (argc == itmp) {
-    p = gsl_permutation_alloc(size);
-    flagp = 1;
-  } else {
-    CHECK_PERMUTATION(argv[itmp]);
-    p = get_permutation(argv[itmp], size, &flagp);
-  }
-  if (flagp == 1 && flagm == 0) rb_raise(rb_eArgError, "permutation must be given");
-  if (flagp == 0) itmp++;
-
-  if (flagm == 1 || flagp == 1) {
-    gsl_linalg_LU_decomp(m, p, &signum);  
-  }
-
-  if (argc-1 == itmp) {
-    CHECK_MATRIX(argv[itmp]);
-    Data_Get_Struct(argv[itmp], gsl_matrix, inverse);
-  } else {
-    inverse = gsl_matrix_alloc(size, size);
-  }
-  gsl_linalg_LU_invert(m, p, inverse);
-  if (flagm == 1) gsl_matrix_free(m);
-  if (flagp == 1) gsl_permutation_free(p);
-  if (argc-1 == itmp) return argv[itmp];
-  else return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, inverse);
-
-}
-
 #ifdef HAVE_NARRAY_H
 static VALUE rb_gsl_linalg_LU_invert_narray(int argc, VALUE *argv, VALUE obj)
 {
@@ -484,7 +410,7 @@ static VALUE rb_gsl_linalg_LU_det_narray(int argc, VALUE *argv, VALUE obj)
   switch (argc) {
   case 2:
     signum = FIX2INT(argv[1]);
-    /* no break */
+  /* no break */
   case 1:
     GetNArray(argv[0], na);
     mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]);
@@ -513,6 +439,51 @@ static VALUE rb_gsl_linalg_LU_lndet_narray(int argc, VALUE *argv, VALUE obj)
 
 #endif
 
+static VALUE rb_gsl_linalg_LU_invert(int argc, VALUE *argv, VALUE obj)
+{
+  gsl_matrix *m = NULL, *inverse = NULL;
+  gsl_permutation *p = NULL;
+  int signum, flagm = 0, flagp = 0, itmp;
+  size_t size;
+  switch (TYPE(obj)) {
+  case T_MODULE:  case T_CLASS:  case T_OBJECT:
+#ifdef HAVE_NARRAY_H
+    if (NA_IsNArray(argv[0]))
+      return rb_gsl_linalg_LU_invert_narray(argc, argv, obj);
+#endif
+    m = get_matrix(argv[0], cgsl_matrix_LU, &flagm);
+    itmp = 1;
+    break;
+  default:
+    m = get_matrix(obj, cgsl_matrix_LU, &flagm);
+    itmp = 0;
+  }
+  size = m->size1;
+
+  if (argc == itmp) {
+    p = gsl_permutation_alloc(size);
+    flagp = 1;
+  } else {
+    CHECK_PERMUTATION(argv[itmp]);
+    p = get_permutation(argv[itmp], size, &flagp);
+  }
+  if (flagp == 1 && flagm == 0) rb_raise(rb_eArgError, "permutation must be given");
+  if (flagp == 0) itmp++;
+  if (flagm == 1 || flagp == 1) {
+    gsl_linalg_LU_decomp(m, p, &signum);
+  }
+  if (argc-1 == itmp) {
+    CHECK_MATRIX(argv[itmp]);
+    Data_Get_Struct(argv[itmp], gsl_matrix, inverse);
+  } else {
+    inverse = gsl_matrix_alloc(size, size);
+  }
+  gsl_linalg_LU_invert(m, p, inverse);
+  if (flagm == 1) gsl_matrix_free(m);
+  if (flagp == 1) gsl_permutation_free(p);
+  if (argc-1 == itmp) return argv[itmp];
+  else return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, inverse);
+}
 static VALUE rb_gsl_linalg_LU_det(int argc, VALUE *argv, VALUE obj)
 {
   gsl_matrix *m = NULL;
@@ -523,7 +494,7 @@ static VALUE rb_gsl_linalg_LU_det(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                           argc);
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_LU_det_narray(argc, argv, obj);
@@ -548,8 +519,8 @@ static VALUE rb_gsl_linalg_LU_det(int argc, VALUE *argv, VALUE obj)
       p = gsl_permutation_alloc(size);
       flagp = 1;
     }
-  } 
-  if (flagm == 1) gsl_linalg_LU_decomp(m, p, &sign);  
+  }
+  if (flagm == 1) gsl_linalg_LU_decomp(m, p, &sign);
   det = gsl_linalg_LU_det(m, sign);
   if (flagm == 1) gsl_matrix_free(m);
   if (flagp == 1) gsl_permutation_free(p);
@@ -566,7 +537,7 @@ static VALUE rb_gsl_linalg_LU_lndet(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc < 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                           argc);
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_LU_lndet_narray(argc, argv, obj);
@@ -580,7 +551,7 @@ static VALUE rb_gsl_linalg_LU_lndet(int argc, VALUE *argv, VALUE obj)
   }
   if (flagm == 1) {
     p = gsl_permutation_alloc(m->size1);
-    gsl_linalg_LU_decomp(m, p, &sign);  
+    gsl_linalg_LU_decomp(m, p, &sign);
   }
   lndet = gsl_linalg_LU_lndet(m);
   if (flagm == 1) {
@@ -607,7 +578,7 @@ static VALUE rb_gsl_linalg_LU_sgndet(int argc, VALUE *argv, VALUE obj)
   }
   if (flagm == 1) {
     p = gsl_permutation_alloc(m->size1);
-    gsl_linalg_LU_decomp(m, p, &sign);  
+    gsl_linalg_LU_decomp(m, p, &sign);
   } else {
     if (argc-itmp != 1) rb_raise(rb_eArgError, "sign must be given");
     sign = FIX2INT(argv[itmp]);
@@ -620,12 +591,11 @@ static VALUE rb_gsl_linalg_LU_sgndet(int argc, VALUE *argv, VALUE obj)
   return INT2FIX(signdet);
 }
 
-#ifdef GSL_1_6_LATER
 int gsl_linalg_LQ_solve_T(const gsl_matrix*, const gsl_vector*, const gsl_vector*, gsl_vector*);
 int gsl_linalg_LQ_svx_T (const gsl_matrix*, const gsl_vector*, gsl_vector*);
-int gsl_linalg_LQ_lssolve_T(const gsl_matrix * LQ, const gsl_vector * tau, 
-                           const gsl_vector * b, gsl_vector * x, 
-                           gsl_vector * residual);
+int gsl_linalg_LQ_lssolve_T(const gsl_matrix * LQ, const gsl_vector * tau,
+                            const gsl_vector * b, gsl_vector * x,
+                            gsl_vector * residual);
 int
 gsl_linalg_LQ_Lsolve_T (const gsl_matrix * LQ, const gsl_vector * b, gsl_vector* x);
 int
@@ -633,9 +603,6 @@ gsl_linalg_LQ_Lsvx_T (const gsl_matrix * LQ, gsl_vector * x);
 int
 gsl_linalg_L_solve_T (const gsl_matrix * L, const gsl_vector * b, gsl_vector * x);
 
-
-#endif
-
 enum {
   LINALG_QR_DECOMP,
   LINALG_QR_DECOMP_BANG,
@@ -660,7 +627,7 @@ enum {
 };
 
 static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj,
-					       int flag)
+                                               int flag)
 {
   gsl_matrix *m = NULL, *mtmp = NULL;
   gsl_vector *tau = NULL;
@@ -680,7 +647,7 @@ static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj,
     break;
   }
   CHECK_MATRIX(omatrix);
-  Data_Get_Struct(omatrix, gsl_matrix, mtmp);    
+  Data_Get_Struct(omatrix, gsl_matrix, mtmp);
 
   switch (flag) {
   case LINALG_QR_DECOMP:
@@ -692,9 +659,8 @@ static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj,
     fdecomp = &gsl_linalg_QR_decomp;
     m = mtmp;
     mdecomp = omatrix;
-    RBASIC(mdecomp)->klass = cgsl_matrix_QR;
+    RBGSL_SET_CLASS(mdecomp, cgsl_matrix_QR);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_DECOMP:
     fdecomp = &gsl_linalg_LQ_decomp;
     m = make_matrix_clone(mtmp);
@@ -704,9 +670,8 @@ static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj,
     fdecomp = &gsl_linalg_LQ_decomp;
     m = mtmp;
     mdecomp = omatrix;
-    RBASIC(mdecomp)->klass = cgsl_matrix_LQ;
+    RBGSL_SET_CLASS(mdecomp, cgsl_matrix_LQ);
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -731,16 +696,16 @@ static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj,
       vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau);
       return rb_ary_new3(2, mdecomp, vtau);
     } else {
-      RBASIC(argv[itmp])->klass = cgsl_vector_tau;
+      RBGSL_SET_CLASS(argv[itmp], cgsl_vector_tau);
       return mdecomp;
     }
     break;
   case LINALG_QR_DECOMP_BANG:
   case LINALG_LQ_DECOMP_BANG:
-   if (argc == itmp) {
+    if (argc == itmp) {
       return Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau);
     } else {
-      RBASIC(argv[itmp])->klass = cgsl_vector_tau;
+      RBGSL_SET_CLASS(argv[itmp], cgsl_vector_tau);
       return INT2FIX(status);
     }
     break;
@@ -752,7 +717,88 @@ static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj,
 }
 
 #ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_QR_decomp_narray(int argc, VALUE *argv, VALUE obj);
+static VALUE rb_gsl_linalg_QR_decomp_narray(int argc, VALUE *argv, VALUE obj)
+{
+  struct NARRAY *na;
+  gsl_matrix_view mv;
+  gsl_vector_view vv;
+  int shapem[2], shapev[1];
+  VALUE qr, tau;
+  if (argc < 1) rb_raise(rb_eArgError, "too few arguments.");
+  GetNArray(argv[0], na);
+  shapem[0] = na->shape[1];
+  shapem[1] = na->shape[1];
+  shapev[0] = shapem[0];
+  qr = na_make_object(NA_DFLOAT, 2, shapem, CLASS_OF(argv[0]));
+  tau = na_make_object(NA_DFLOAT, 1, shapev, cNVector);
+  memcpy(NA_PTR_TYPE(qr,double*),na->ptr,sizeof(double)*shapem[0]*shapem[1]);
+  mv = gsl_matrix_view_array(NA_PTR_TYPE(qr,double*), shapem[0], shapem[1]);
+  vv = gsl_vector_view_array(NA_PTR_TYPE(tau,double*), shapev[0]);
+  gsl_linalg_QR_decomp(&mv.matrix, &vv.vector);
+  return rb_ary_new3(2, qr, tau);
+}
+
+static VALUE rb_gsl_linalg_QR_unpack_narray(int argc, VALUE *argv, VALUE obj)
+{
+  struct NARRAY *m, *tau;
+  gsl_matrix_view mv, mq, mr;
+  gsl_vector_view vv;
+  int shape[2];
+  VALUE q, r;
+  if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+                          argc);
+  GetNArray(argv[0], m);
+  GetNArray(argv[1], tau);
+  mv = gsl_matrix_view_array((double*)m->ptr, m->shape[1], m->shape[0]);
+  vv = gsl_vector_view_array((double*)tau->ptr, tau->shape[0]);
+  shape[0] = m->shape[1];
+  shape[1] = m->shape[1];
+  q = na_make_object(NA_DFLOAT, 2, shape, CLASS_OF(argv[0]));
+  shape[0] = m->shape[1];
+  shape[1] = m->shape[0];
+  r = na_make_object(NA_DFLOAT, 2, shape, CLASS_OF(argv[0]));
+  mq = gsl_matrix_view_array(NA_PTR_TYPE(q,double*), m->shape[1], m->shape[1]);
+  mr = gsl_matrix_view_array(NA_PTR_TYPE(r,double*), m->shape[1], m->shape[0]);
+  //  printf("OK 4 %d %d\n", mq.matrix.size1, mr.matrix.size2);
+  gsl_linalg_QR_unpack(&mv.matrix, &vv.vector, &mq.matrix, &mr.matrix);
+  //  printf("OK 5\n");
+  return rb_ary_new3(2, q, r);
+}
+
+static VALUE rb_gsl_linalg_QR_solve_narray(int argc, VALUE *argv, VALUE obj)
+{
+  struct NARRAY *qr, *tau, *b;
+  VALUE x;
+  gsl_matrix_view mv;
+  gsl_vector_view tv, bv, xv;
+  if (argc != 3) rb_raise(rb_eArgError, "Usage: QR.solve(qr, tau, b)");
+  GetNArray(argv[0], qr);
+  GetNArray(argv[1], tau);
+  GetNArray(argv[2], b);
+  x = na_make_object(NA_DFLOAT, 1, b->shape, CLASS_OF(argv[2]));
+  mv = gsl_matrix_view_array((double*)qr->ptr, qr->shape[1], qr->shape[0]);
+  tv = gsl_vector_view_array((double*)tau->ptr, tau->shape[0]);
+  bv = gsl_vector_view_array((double*)b->ptr, b->shape[0]);
+  xv = gsl_vector_view_array(NA_PTR_TYPE(x,double*), b->shape[0]);
+  gsl_linalg_QR_solve(&mv.matrix, &tv.vector, &bv.vector, &xv.vector);
+  return x;
+}
+static VALUE rb_gsl_linalg_QR_svx_narray(int argc, VALUE *argv, VALUE obj)
+{
+  struct NARRAY *qr, *tau, *b;
+  gsl_matrix_view mv;
+  gsl_vector_view tv, bv;
+  if (argc != 3) rb_raise(rb_eArgError, "Usage: QR.solve(qr, tau, b)");
+  GetNArray(argv[0], qr);
+  GetNArray(argv[1], tau);
+  GetNArray(argv[2], b);
+  mv = gsl_matrix_view_array((double*)qr->ptr, qr->shape[1], qr->shape[0]);
+  tv = gsl_vector_view_array((double*)tau->ptr, tau->shape[0]);
+  bv = gsl_vector_view_array((double*)b->ptr, b->shape[0]);
+  gsl_linalg_QR_svx(&mv.matrix, &tv.vector, &bv.vector);
+  return argv[2];
+}
+
 #endif
 
 static VALUE rb_gsl_linalg_QR_decomp(int argc, VALUE *argv, VALUE obj)
@@ -769,7 +815,6 @@ static VALUE rb_gsl_linalg_QR_decomp_bang(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_QR_DECOMP_BANG);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_LQ_decomp(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_LQ_DECOMP);
@@ -779,7 +824,6 @@ static VALUE rb_gsl_linalg_LQ_decomp_bang(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_LQ_DECOMP_BANG);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QR_LQ_solve(int argc, VALUE *argv, VALUE obj, int flag)
 {
@@ -811,13 +855,11 @@ static VALUE rb_gsl_linalg_QR_LQ_solve(int argc, VALUE *argv, VALUE obj, int fla
     fdecomp = &gsl_linalg_QR_decomp;
     fsolve = &gsl_linalg_QR_solve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_SOLVE:
     m = get_matrix(omatrix, cgsl_matrix_LQ, &flagm);
     fdecomp = &gsl_linalg_LQ_decomp;
     fsolve = &gsl_linalg_LQ_solve_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operatioin");
     break;
@@ -879,7 +921,7 @@ static VALUE rb_gsl_linalg_QR_LQ_svx(int argc, VALUE *argv, VALUE obj, int flag)
     itmp = 0;
     break;
   }
-  if (argc-itmp < 1 || argc-itmp > 2) 
+  if (argc-itmp < 1 || argc-itmp > 2)
     rb_raise(rb_eArgError,  "wrong number of arguments");
   CHECK_MATRIX(omatrix);
   switch (flag) {
@@ -888,13 +930,11 @@ static VALUE rb_gsl_linalg_QR_LQ_svx(int argc, VALUE *argv, VALUE obj, int flag)
     fdecomp = &gsl_linalg_QR_decomp;
     fsvx = &gsl_linalg_QR_svx;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_SOLVE:
     m = get_matrix(omatrix, cgsl_matrix_LQ, &flagm);
     fdecomp = &gsl_linalg_LQ_decomp;
     fsvx = &gsl_linalg_LQ_svx_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operatioin");
     break;
@@ -933,7 +973,7 @@ static VALUE rb_gsl_linalg_QR_LQ_lssolve(int argc, VALUE *argv, VALUE obj, int f
   size_t size;
   int (*fdecomp)(gsl_matrix*, gsl_vector*);
   int (*flssolve)(const gsl_matrix*, const gsl_vector*, const gsl_vector*, gsl_vector*,
-		  gsl_vector*);
+                  gsl_vector*);
 
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
@@ -955,13 +995,11 @@ static VALUE rb_gsl_linalg_QR_LQ_lssolve(int argc, VALUE *argv, VALUE obj, int f
     fdecomp = &gsl_linalg_QR_decomp;
     flssolve = &gsl_linalg_QR_lssolve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_SOLVE:
     m = get_matrix(omatrix, cgsl_matrix_LQ, &flagm);
     fdecomp = &gsl_linalg_LQ_decomp;
     flssolve = &gsl_linalg_LQ_lssolve_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operatioin");
     break;
@@ -1010,7 +1048,6 @@ static VALUE rb_gsl_linalg_QR_LQ_lssolve(int argc, VALUE *argv, VALUE obj, int f
   if (flagm == 1) gsl_matrix_free(m);
   if (flagt == 1) gsl_vector_free(tau);
   if (flagb == 1) gsl_vector_free(b);
-
   switch (argc - itmp) {
   case 2:
     return INT2FIX(status);
@@ -1020,16 +1057,11 @@ static VALUE rb_gsl_linalg_QR_LQ_lssolve(int argc, VALUE *argv, VALUE obj, int f
     break;
   default:
     return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x),
-		       Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, r));
+                       Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, r));
   }
   return Qnil;
 }
 
-#ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_QR_solve_narray(int argc, VALUE *argv, VALUE obj);
-static VALUE rb_gsl_linalg_QR_svx_narray(int argc, VALUE *argv, VALUE obj);
-#endif
-
 static VALUE rb_gsl_linalg_QR_solve(int argc, VALUE *argv, VALUE obj)
 {
 #ifdef HAVE_NARRAY_H
@@ -1053,7 +1085,6 @@ static VALUE rb_gsl_linalg_QR_lssolve(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QR_LQ_lssolve(argc, argv, obj, LINALG_QR_SOLVE);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_LQ_solve(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QR_LQ_solve(argc, argv, obj, LINALG_LQ_SOLVE);
@@ -1068,18 +1099,17 @@ static VALUE rb_gsl_linalg_LQ_lssolve(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QR_LQ_lssolve(argc, argv, obj, LINALG_LQ_SOLVE);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQ_QTvec(int argc, VALUE *argv, VALUE obj,
-				      int flag)
+                                      int flag)
 {
   gsl_matrix *QR = NULL;
   gsl_vector *tau = NULL, *v = NULL;
   VALUE ret;
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
-    if (argc != 3) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for 3)", argc); 
+    if (argc != 3) rb_raise(rb_eArgError,
+                            "wrong number of arguments (%d for 3)", argc);
     CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]);
     Data_Get_Struct(argv[0], gsl_matrix, QR);
     Data_Get_Struct(argv[1], gsl_vector, tau);
@@ -1087,8 +1117,8 @@ static VALUE rb_gsl_linalg_QRLQ_QTvec(int argc, VALUE *argv, VALUE obj,
     ret = argv[2];
     break;
   default:
-    if (argc != 2) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for 2)", argc); 
+    if (argc != 2) rb_raise(rb_eArgError,
+                            "wrong number of arguments (%d for 2)", argc);
     CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[1]);
     Data_Get_Struct(obj, gsl_matrix, QR);
     Data_Get_Struct(argv[0], gsl_vector, tau);
@@ -1103,14 +1133,12 @@ static VALUE rb_gsl_linalg_QRLQ_QTvec(int argc, VALUE *argv, VALUE obj,
   case LINALG_QR_Qvec:
     gsl_linalg_QR_Qvec(QR, tau, v);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_vecQ:
     gsl_linalg_LQ_vecQ(QR, tau, v);
     break;
   case LINALG_LQ_vecQT:
     gsl_linalg_LQ_vecQT(QR, tau, v);
     break;
-#endif
   default:
     break;
   }
@@ -1127,7 +1155,6 @@ static VALUE rb_gsl_linalg_QR_Qvec(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_QR_Qvec);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_LQ_vecQT(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_LQ_vecQT);
@@ -1137,10 +1164,9 @@ static VALUE rb_gsl_linalg_LQ_vecQ(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_LQ_vecQ);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQ_unpack(int argc, VALUE *argv, VALUE obj,
-				       int flag)
+                                       int flag)
 {
   gsl_matrix *QR = NULL, *Q = NULL, *R = NULL;
   gsl_vector *tau = NULL;
@@ -1159,14 +1185,14 @@ static VALUE rb_gsl_linalg_QRLQ_unpack(int argc, VALUE *argv, VALUE obj,
   }
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
-    if (argc != 2) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for 2)", argc);
+    if (argc != 2) rb_raise(rb_eArgError,
+                            "wrong number of arguments (%d for 2)", argc);
     vtmp = argv[0];
     itmp = 1;
     break;
   default:
-    if (argc != 1) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for 1)", argc);
+    if (argc != 1) rb_raise(rb_eArgError,
+                            "wrong number of arguments (%d for 1)", argc);
     vtmp = obj;
     itmp = 0;
     break;
@@ -1187,13 +1213,11 @@ static VALUE rb_gsl_linalg_QRLQ_unpack(int argc, VALUE *argv, VALUE obj,
     vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q);
     vR = Data_Wrap_Struct(cgsl_matrix_R, 0, gsl_matrix_free, R);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_UNPACK:
-  gsl_linalg_LQ_unpack(QR, tau, Q, R);
-  vQ = Data_Wrap_Struct(cgsl_matrix_L, 0, gsl_matrix_free, Q);
-  vR = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, R);
+    gsl_linalg_LQ_unpack(QR, tau, Q, R);
+    vQ = Data_Wrap_Struct(cgsl_matrix_L, 0, gsl_matrix_free, Q);
+    vR = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, R);
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1201,10 +1225,6 @@ static VALUE rb_gsl_linalg_QRLQ_unpack(int argc, VALUE *argv, VALUE obj,
   return rb_ary_new3(2, vQ, vR);
 }
 
-#ifdef HAVE_NARRAY_H
-static VALUE rb_gsl_linalg_QR_unpack_narray(int argc, VALUE *argv, VALUE obj);
-#endif
-
 static VALUE rb_gsl_linalg_QR_unpack(int argc, VALUE *argv, VALUE obj)
 {
 #ifdef HAVE_NARRAY_H
@@ -1214,16 +1234,14 @@ static VALUE rb_gsl_linalg_QR_unpack(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QRLQ_unpack(argc, argv, obj, LINALG_QR_UNPACK);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_LQ_unpack(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQ_unpack(argc, argv, obj, LINALG_LQ_UNPACK);
 }
-#endif
 
 /* singleton */
 static VALUE rb_gsl_linalg_QRLQ_QRLQsolve(int argc, VALUE *argv, VALUE obj,
-					  int flag)
+                                          int flag)
 {
   gsl_matrix *Q = NULL, *R = NULL;
   gsl_vector *b = NULL, *x = NULL;
@@ -1252,21 +1270,19 @@ static VALUE rb_gsl_linalg_QRLQ_QRLQsolve(int argc, VALUE *argv, VALUE obj,
   }
   switch (flag) {
   case LINALG_QR_DECOMP:
-    if (CLASS_OF(argv[0]) != cgsl_matrix_Q) 
+    if (CLASS_OF(argv[0]) != cgsl_matrix_Q)
       rb_raise(rb_eTypeError, "not a Q matrix");
-    if (CLASS_OF(argv[1]) != cgsl_matrix_R) 
+    if (CLASS_OF(argv[1]) != cgsl_matrix_R)
       rb_raise(rb_eTypeError, "not a R matrix");
     fsolve = &gsl_linalg_QR_QRsolve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_DECOMP:
-    /*    if (CLASS_OF(argv[0]) != cgsl_matrix_L) 
+    /*    if (CLASS_OF(argv[0]) != cgsl_matrix_L)
       rb_raise(rb_eTypeError, "not a L matrix");
-    if (CLASS_OF(argv[1]) != cgsl_matrix_Q) 
+    if (CLASS_OF(argv[1]) != cgsl_matrix_Q)
     rb_raise(rb_eTypeError, "not a Q matrix");*/
     fsolve = &gsl_linalg_LQ_LQsolve;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1285,7 +1301,7 @@ static VALUE rb_gsl_linalg_QRLQ_QRLQsolve(int argc, VALUE *argv, VALUE obj,
 
 /*****/
 static VALUE rb_gsl_linalg_QRLQ_RLsolve(int argc, VALUE *argv, VALUE obj,
-					  int flag)
+                                        int flag)
 {
   gsl_matrix *QR = NULL, *mtmp;
   gsl_vector *b = NULL, *x = NULL, *tau = NULL;
@@ -1339,7 +1355,6 @@ static VALUE rb_gsl_linalg_QRLQ_RLsolve(int argc, VALUE *argv, VALUE obj,
     }
     fsolve = &gsl_linalg_R_solve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_LSOLVE:
     if (CLASS_OF(omatrix) != cgsl_matrix_LQ) {
       QR = make_matrix_clone(mtmp);
@@ -1358,7 +1373,6 @@ static VALUE rb_gsl_linalg_QRLQ_RLsolve(int argc, VALUE *argv, VALUE obj,
     }
     fsolve = &gsl_linalg_L_solve_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1380,7 +1394,7 @@ static VALUE rb_gsl_linalg_QRLQ_RLsolve(int argc, VALUE *argv, VALUE obj,
 }
 
 static VALUE rb_gsl_linalg_QRLQ_RLsvx(int argc, VALUE *argv, VALUE obj,
-					  int flag)
+                                      int flag)
 {
   gsl_matrix *QR = NULL, *mtmp;
   gsl_vector *x = NULL, *tau = NULL;
@@ -1425,18 +1439,17 @@ static VALUE rb_gsl_linalg_QRLQ_RLsvx(int argc, VALUE *argv, VALUE obj,
     }
     fsolve = &gsl_linalg_QR_Rsvx;
     break;
-    /*
-  case LINALG_R_SVX:
-    if (CLASS_OF(omatrix) != cgsl_matrix_QR) {
-      QR = make_matrix_clone(mtmp);
-      tau = gsl_vector_alloc(QR->size1);
-      gsl_linalg_QR_decomp(QR, tau);
-      flagq = 1;
-    }
-    fsolve = &gsl_linalg_R_svx;
-    break;
-    */
-#ifdef GSL_1_6_LATER
+  /*
+case LINALG_R_SVX:
+  if (CLASS_OF(omatrix) != cgsl_matrix_QR) {
+    QR = make_matrix_clone(mtmp);
+    tau = gsl_vector_alloc(QR->size1);
+    gsl_linalg_QR_decomp(QR, tau);
+    flagq = 1;
+  }
+  fsolve = &gsl_linalg_R_svx;
+  break;
+  */
   case LINALG_LQ_LSVX:
     if (CLASS_OF(omatrix) != cgsl_matrix_LQ) {
       QR = make_matrix_clone(mtmp);
@@ -1446,7 +1459,6 @@ static VALUE rb_gsl_linalg_QRLQ_RLsvx(int argc, VALUE *argv, VALUE obj,
     }
     fsolve = &gsl_linalg_LQ_Lsvx_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1476,12 +1488,11 @@ static VALUE rb_gsl_linalg_R_solve(int argc, VALUE *argv, VALUE obj)
 
 /* singleton */
 static VALUE rb_gsl_linalg_QR_QRsolve(int argc, VALUE *argv, VALUE obj,
-					  int flag)
+                                      int flag)
 {
   return rb_gsl_linalg_QRLQ_QRLQsolve(argc, argv, obj, LINALG_QR_DECOMP);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_LQ_Lsolve(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQ_RLsolve(argc, argv, obj, LINALG_LQ_LSOLVE);
@@ -1499,14 +1510,13 @@ static VALUE rb_gsl_linalg_L_solve(int argc, VALUE *argv, VALUE obj)
 
 /* singleton */
 static VALUE rb_gsl_linalg_LQ_LQsolve(int argc, VALUE *argv, VALUE obj,
-					  int flag)
+                                      int flag)
 {
   return rb_gsl_linalg_QRLQ_QRLQsolve(argc, argv, obj, LINALG_LQ_DECOMP);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww,
-				     VALUE vv, int flag)
+                                       VALUE vv, int flag)
 {
   gsl_matrix *Q = NULL, *R = NULL;
   gsl_vector *w = NULL, *v = NULL;
@@ -1521,11 +1531,9 @@ static VALUE rb_gsl_linalg_QRLQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww,
   case LINALG_QR_DECOMP:
     status = gsl_linalg_QR_update(Q, R, w, v);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_LQ_DECOMP:
     status = gsl_linalg_LQ_update(Q, R, w, v);
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1535,18 +1543,16 @@ static VALUE rb_gsl_linalg_QRLQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww,
 
 /* singleton */
 static VALUE rb_gsl_linalg_QR_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww,
-				     VALUE vv)
+                                     VALUE vv)
 {
   return rb_gsl_linalg_QRLQ_update(obj, qq, rr, ww, vv, LINALG_QR_DECOMP);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_LQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww,
-				     VALUE vv)
+                                     VALUE vv)
 {
   return rb_gsl_linalg_QRLQ_update(obj, qq, rr, ww, vv, LINALG_LQ_DECOMP);
 }
-#endif
 
 /******/
 enum {
@@ -1565,7 +1571,7 @@ static VALUE rb_gsl_linalg_QRLQPT_decomp(int argc, VALUE *argv, VALUE obj, int f
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                            argc);
     vA = argv[0];
     break;
   default:
@@ -1586,14 +1592,12 @@ static VALUE rb_gsl_linalg_QRLQPT_decomp(int argc, VALUE *argv, VALUE obj, int f
     vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p);
     gsl_linalg_QRPT_decomp(QR, tau, p, &signum, norm);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     vQR = Data_Wrap_Struct(cgsl_matrix_PTLQ, 0, gsl_matrix_free, QR);
     vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau);
     vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p);
     gsl_linalg_PTLQ_decomp(QR, tau, p, &signum, norm);
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1613,7 +1617,7 @@ static VALUE rb_gsl_linalg_QRLQPT_decomp_bang(int argc, VALUE *argv, VALUE obj,
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                            argc);
     vA = argv[0];
     break;
   default:
@@ -1628,19 +1632,17 @@ static VALUE rb_gsl_linalg_QRLQPT_decomp_bang(int argc, VALUE *argv, VALUE obj,
   norm = gsl_vector_alloc(size0);
   switch (flag) {
   case LINALG_QRPT:
-    RBASIC(vA)->klass = cgsl_matrix_QRPT;
+    RBGSL_SET_CLASS(vA, cgsl_matrix_QRPT);
     vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau);
     vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p);
     gsl_linalg_QRPT_decomp(A, tau, p, &signum, norm);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
-    RBASIC(vA)->klass = cgsl_matrix_PTLQ;
+    RBGSL_SET_CLASS(vA, cgsl_matrix_PTLQ);
     vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau);
     vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p);
     gsl_linalg_PTLQ_decomp(A, tau, p, &signum, norm);
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1659,7 +1661,6 @@ static VALUE rb_gsl_linalg_QRPT_decomp_bang(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QRLQPT_decomp_bang(argc, argv, obj, LINALG_QRPT);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_PTLQ_decomp(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_decomp(argc, argv, obj, LINALG_PTLQ);
@@ -1669,7 +1670,6 @@ static VALUE rb_gsl_linalg_PTLQ_decomp_bang(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_decomp_bang(argc, argv, obj, LINALG_PTLQ);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQPT_decomp2(int argc, VALUE *argv, VALUE obj,int flag)
 {
@@ -1707,13 +1707,11 @@ static VALUE rb_gsl_linalg_QRLQPT_decomp2(int argc, VALUE *argv, VALUE obj,int f
     vR = Data_Wrap_Struct(cgsl_matrix_R, 0, gsl_matrix_free, R);
     gsl_linalg_QRPT_decomp2(A, Q, R, tau, p, &signum, norm);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     vR = Data_Wrap_Struct(cgsl_matrix_L, 0, gsl_matrix_free, R);
     vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q);
     gsl_linalg_PTLQ_decomp2(A, Q, R, tau, p, &signum, norm);
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
   }
@@ -1726,33 +1724,29 @@ static VALUE rb_gsl_linalg_QRPT_decomp2(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QRLQPT_decomp2(argc, argv, obj, LINALG_QRPT);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_PTLQ_decomp2(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_decomp2(argc, argv, obj, LINALG_PTLQ);
 }
-#endif
 
-#ifdef GSL_1_6_LATER
 int gsl_linalg_PTLQ_solve_T(const gsl_matrix * QR, const gsl_vector * tau,
-			    const gsl_permutation * p, const gsl_vector * b, 
-			    gsl_vector * x);
+                            const gsl_permutation * p, const gsl_vector * b,
+                            gsl_vector * x);
 int gsl_linalg_PTLQ_svx_T(const gsl_matrix * LQ,
-                         const gsl_vector * tau,
-                         const gsl_permutation * p,
-                         gsl_vector * x);
+                          const gsl_vector * tau,
+                          const gsl_permutation * p,
+                          gsl_vector * x);
 int gsl_linalg_PTLQ_LQsolve_T (const gsl_matrix * Q, const gsl_matrix * L,
-                           const gsl_permutation * p,
-                           const gsl_vector * b,
-                           gsl_vector * x);
+                               const gsl_permutation * p,
+                               const gsl_vector * b,
+                               gsl_vector * x);
 int gsl_linalg_PTLQ_Lsolve_T (const gsl_matrix * LQ,
-                        const gsl_permutation * p,
-                        const gsl_vector * b,
-			  gsl_vector * x);
+                              const gsl_permutation * p,
+                              const gsl_vector * b,
+                              gsl_vector * x);
 int gsl_linalg_PTLQ_Lsvx_T (const gsl_matrix * LQ,
-                        const gsl_permutation * p,
-                        gsl_vector * x);
-#endif
+                            const gsl_permutation * p,
+                            gsl_vector * x);
 
 static VALUE rb_gsl_linalg_QRLQPT_solve(int argc, VALUE *argv, VALUE obj, int flag)
 {
@@ -1763,21 +1757,19 @@ static VALUE rb_gsl_linalg_QRLQPT_solve(int argc, VALUE *argv, VALUE obj, int fl
   VALUE vtmp, klass;
   size_t size0;
   int (*fdecomp)(gsl_matrix*, gsl_vector*, gsl_permutation*, int *, gsl_vector*);
-  int (*fsolve)(const gsl_matrix*, const gsl_vector*, const gsl_permutation*, 
-		const gsl_vector*, gsl_vector *);
+  int (*fsolve)(const gsl_matrix*, const gsl_vector*, const gsl_permutation*,
+                const gsl_vector*, gsl_vector *);
   switch (flag) {
   case LINALG_QRPT:
     klass = cgsl_matrix_QRPT;
     fdecomp = &gsl_linalg_QRPT_decomp;
     fsolve = &gsl_linalg_QRPT_solve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     klass = cgsl_matrix_PTLQ;
     fdecomp = &gsl_linalg_PTLQ_decomp;
     fsolve = &gsl_linalg_PTLQ_solve_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1795,11 +1787,11 @@ static VALUE rb_gsl_linalg_QRLQPT_solve(int argc, VALUE *argv, VALUE obj, int fl
   }
   CHECK_MATRIX(vtmp);
   if (CLASS_OF(vtmp) == klass) {
-    if (argc-itmp != 3) rb_raise(rb_eArgError, 
-				 "wrong number of arguments (%d for %d)", 
-				 argc, 4-itmp);
+    if (argc-itmp != 3) rb_raise(rb_eArgError,
+                                 "wrong number of arguments (%d for %d)",
+                                 argc, 4-itmp);
     CHECK_VECTOR(argv[itmp]);
-    if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) 
+    if (CLASS_OF(argv[itmp]) != cgsl_vector_tau)
       rb_raise(rb_eTypeError, "not a tau vector");
     CHECK_PERMUTATION(argv[itmp+1]);
     Data_Get_Struct(argv[itmp], gsl_vector, tau);
@@ -1808,8 +1800,8 @@ static VALUE rb_gsl_linalg_QRLQPT_solve(int argc, VALUE *argv, VALUE obj, int fl
     size0 = GSL_MIN(QR->size1, QR->size2);
     itmp += 2;
   } else {
-    if (argc-itmp != 1) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for %d)", argc, 2-itmp);
+    if (argc-itmp != 1) rb_raise(rb_eArgError,
+                                 "wrong number of arguments (%d for %d)", argc, 2-itmp);
     Data_Get_Struct(vtmp, gsl_matrix, A);
     QR = make_matrix_clone(A);
     size0 = GSL_MIN(QR->size1, QR->size2);
@@ -1843,12 +1835,10 @@ static VALUE rb_gsl_linalg_QRPT_solve(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QRLQPT_solve(argc, argv, obj, LINALG_QRPT);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_PTLQ_solve(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_solve(argc, argv, obj, LINALG_PTLQ);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQPT_svx(int argc, VALUE *argv, VALUE obj, int flag)
 {
@@ -1859,21 +1849,19 @@ static VALUE rb_gsl_linalg_QRLQPT_svx(int argc, VALUE *argv, VALUE obj, int flag
   VALUE vtmp, klass;
   size_t size0;
   int (*fdecomp)(gsl_matrix*, gsl_vector*, gsl_permutation*, int *, gsl_vector*);
-  int (*fsvx)(const gsl_matrix*, const gsl_vector*, const gsl_permutation*, 
-	      gsl_vector *);
+  int (*fsvx)(const gsl_matrix*, const gsl_vector*, const gsl_permutation*,
+              gsl_vector *);
   switch (flag) {
   case LINALG_QRPT:
     klass = cgsl_matrix_QRPT;
     fdecomp = &gsl_linalg_QRPT_decomp;
     fsvx = &gsl_linalg_QRPT_svx;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     klass = cgsl_matrix_PTLQ;
     fdecomp = &gsl_linalg_PTLQ_decomp;
     fsvx = &gsl_linalg_PTLQ_svx_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1882,7 +1870,7 @@ static VALUE rb_gsl_linalg_QRLQPT_svx(int argc, VALUE *argv, VALUE obj, int flag
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                            argc);
     vtmp = argv[0];
     itmp = 1;
     break;
@@ -1893,11 +1881,11 @@ static VALUE rb_gsl_linalg_QRLQPT_svx(int argc, VALUE *argv, VALUE obj, int flag
   }
   CHECK_MATRIX(vtmp);
   if (CLASS_OF(vtmp) == klass) {
-    if (argc-itmp != 3) rb_raise(rb_eArgError, 
-				 "wrong number of arguments (%d for %d)", 
-				 argc, 3+itmp);
+    if (argc-itmp != 3) rb_raise(rb_eArgError,
+                                 "wrong number of arguments (%d for %d)",
+                                 argc, 3+itmp);
     CHECK_VECTOR(argv[itmp]);
-    if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) 
+    if (CLASS_OF(argv[itmp]) != cgsl_vector_tau)
       rb_raise(rb_eTypeError, "not a tau vector");
     CHECK_PERMUTATION(argv[itmp+1]);
     Data_Get_Struct(argv[itmp], gsl_vector, tau);
@@ -1906,8 +1894,8 @@ static VALUE rb_gsl_linalg_QRLQPT_svx(int argc, VALUE *argv, VALUE obj, int flag
     size0 = GSL_MIN(QR->size1, QR->size2);
     itmp += 2;
   } else {
-    if (argc-itmp != 1) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for %d)", argc, 2+itmp);
+    if (argc-itmp != 1) rb_raise(rb_eArgError,
+                                 "wrong number of arguments (%d for %d)", argc, 2+itmp);
     Data_Get_Struct(vtmp, gsl_matrix, A);
     QR = make_matrix_clone(A);
     size0 = GSL_MIN(QR->size1, QR->size2);
@@ -1934,36 +1922,32 @@ static VALUE rb_gsl_linalg_QRPT_svx(int argc, VALUE *argv, VALUE obj)
   return rb_gsl_linalg_QRLQPT_svx(argc, argv, obj, LINALG_QRPT);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_linalg_PTLQ_svx(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_svx(argc, argv, obj, LINALG_PTLQ);
 }
-#endif
 
 /* singleton */
-static VALUE rb_gsl_linalg_QRLQPT_QRLQsolve(VALUE obj, VALUE qq, VALUE rr, 
-					    VALUE pp, VALUE bb, int flag)
+static VALUE rb_gsl_linalg_QRLQPT_QRLQsolve(VALUE obj, VALUE qq, VALUE rr,
+                                            VALUE pp, VALUE bb, int flag)
 {
   gsl_matrix *Q = NULL, *R = NULL;
   gsl_vector *b = NULL, *x = NULL;
   gsl_permutation *p = NULL;
   int flagb = 0;
-  int (*fsolve)(const gsl_matrix*, const gsl_matrix*, const gsl_permutation*, 
-		const gsl_vector*, gsl_vector*);
+  int (*fsolve)(const gsl_matrix*, const gsl_matrix*, const gsl_permutation*,
+                const gsl_vector*, gsl_vector*);
   switch (flag) {
   case LINALG_QRPT:
     if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix");
     if (CLASS_OF(rr) != cgsl_matrix_R) rb_raise(rb_eTypeError, "not a R matrix");
     fsolve = &gsl_linalg_QRPT_QRsolve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix");
     if (CLASS_OF(rr) != cgsl_matrix_L) rb_raise(rb_eTypeError, "not a L matrix");
     fsolve = &gsl_linalg_PTLQ_LQsolve_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -1985,23 +1969,21 @@ static VALUE rb_gsl_linalg_QRLQPT_QRLQsolve(VALUE obj, VALUE qq, VALUE rr,
   return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x);
 }
 
-static VALUE rb_gsl_linalg_QRPT_QRsolve(VALUE obj, VALUE qq, VALUE rr, 
-					VALUE pp, VALUE bb)
+static VALUE rb_gsl_linalg_QRPT_QRsolve(VALUE obj, VALUE qq, VALUE rr,
+                                        VALUE pp, VALUE bb)
 {
   return rb_gsl_linalg_QRLQPT_QRLQsolve(obj, qq, rr, pp, bb, LINALG_QRPT);
 }
 
-#ifdef GSL_1_6_LATER
-static VALUE rb_gsl_linalg_PTLQ_LQsolve(VALUE obj, VALUE qq, VALUE rr, 
-					VALUE pp, VALUE bb)
+static VALUE rb_gsl_linalg_PTLQ_LQsolve(VALUE obj, VALUE qq, VALUE rr,
+                                        VALUE pp, VALUE bb)
 {
   return rb_gsl_linalg_QRLQPT_QRLQsolve(obj, qq, rr, pp, bb, LINALG_PTLQ);
 }
-#endif
 
 /* singleton */
-static VALUE rb_gsl_linalg_QRLQPT_update(VALUE obj, VALUE qq, VALUE rr, 
-				       VALUE pp, VALUE ww, VALUE vv, int flag)
+static VALUE rb_gsl_linalg_QRLQPT_update(VALUE obj, VALUE qq, VALUE rr,
+                                         VALUE pp, VALUE ww, VALUE vv, int flag)
 {
   gsl_matrix *Q = NULL, *R = NULL;
   gsl_vector *w = NULL, *v = NULL;
@@ -2011,12 +1993,10 @@ static VALUE rb_gsl_linalg_QRLQPT_update(VALUE obj, VALUE qq, VALUE rr,
     if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix");
     if (CLASS_OF(rr) != cgsl_matrix_R) rb_raise(rb_eTypeError, "not a R matrix");
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix");
     if (CLASS_OF(rr) != cgsl_matrix_L) rb_raise(rb_eTypeError, "not a L matrix");
     break;
-#endif
   }
   CHECK_PERMUTATION(pp);
   Data_Get_Struct(qq, gsl_matrix, Q);
@@ -2028,28 +2008,24 @@ static VALUE rb_gsl_linalg_QRLQPT_update(VALUE obj, VALUE qq, VALUE rr,
   case LINALG_QRPT:
     gsl_linalg_QRPT_update(Q, R, p, w, v);
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     gsl_linalg_PTLQ_update(Q, R, p, w, v);
     break;
-#endif
   }
   return obj;
 }
 
-static VALUE rb_gsl_linalg_QRPT_update(VALUE obj, VALUE qq, VALUE rr, 
-				       VALUE pp, VALUE ww, VALUE vv)
+static VALUE rb_gsl_linalg_QRPT_update(VALUE obj, VALUE qq, VALUE rr,
+                                       VALUE pp, VALUE ww, VALUE vv)
 {
   return rb_gsl_linalg_QRLQPT_update(obj, qq, rr, pp, ww, vv, LINALG_QRPT);
 }
 
-#ifdef GSL_1_6_LATER
-static VALUE rb_gsl_linalg_PTLQ_update(VALUE obj, VALUE qq, VALUE rr, 
-				       VALUE pp, VALUE ww, VALUE vv)
+static VALUE rb_gsl_linalg_PTLQ_update(VALUE obj, VALUE qq, VALUE rr,
+                                       VALUE pp, VALUE ww, VALUE vv)
 {
   return rb_gsl_linalg_QRLQPT_update(obj, qq, rr, pp, ww, vv, LINALG_PTLQ);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQPT_RLsolve(int argc, VALUE *argv, VALUE obj, int flag)
 {
@@ -2058,19 +2034,17 @@ static VALUE rb_gsl_linalg_QRLQPT_RLsolve(int argc, VALUE *argv, VALUE obj, int
   gsl_permutation *p = NULL;
   int itmp, flagb = 0;
   VALUE vtmp, klass;
-  int (*fsolve)(const gsl_matrix*, const gsl_permutation*, const gsl_vector*, 
-		gsl_vector*);
+  int (*fsolve)(const gsl_matrix*, const gsl_permutation*, const gsl_vector*,
+                gsl_vector*);
   switch (flag) {
   case LINALG_QRPT:
     klass = cgsl_matrix_QRPT;
     fsolve = &gsl_linalg_QRPT_Rsolve;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     klass = cgsl_matrix_PTLQ;
     fsolve = &gsl_linalg_PTLQ_Lsolve_T;
     break;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -2078,7 +2052,7 @@ static VALUE rb_gsl_linalg_QRLQPT_RLsolve(int argc, VALUE *argv, VALUE obj, int
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                            argc);
     vtmp = argv[0];
     itmp = 1;
     break;
@@ -2114,12 +2088,11 @@ static VALUE rb_gsl_linalg_QRPT_Rsolve(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_RLsolve(argc, argv, obj, LINALG_QRPT);
 }
-#ifdef GSL_1_6_LATER
+
 static VALUE rb_gsl_linalg_PTLQ_Lsolve(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_RLsolve(argc, argv, obj, LINALG_PTLQ);
 }
-#endif
 
 static VALUE rb_gsl_linalg_QRLQPT_RLsvx(int argc, VALUE *argv, VALUE obj, int flag)
 {
@@ -2134,11 +2107,9 @@ static VALUE rb_gsl_linalg_QRLQPT_RLsvx(int argc, VALUE *argv, VALUE obj, int fl
     klass = cgsl_matrix_QRPT;
     fsvx = &gsl_linalg_QRPT_Rsvx;
     break;
-#ifdef GSL_1_6_LATER
   case LINALG_PTLQ:
     klass = cgsl_matrix_PTLQ;
     fsvx = &gsl_linalg_PTLQ_Lsvx_T;
-#endif
   default:
     rb_raise(rb_eRuntimeError, "unknown operation");
     break;
@@ -2146,7 +2117,7 @@ static VALUE rb_gsl_linalg_QRLQPT_RLsvx(int argc, VALUE *argv, VALUE obj, int fl
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                            argc);
     vtmp = argv[0];
     itmp = 1;
     break;
@@ -2179,12 +2150,11 @@ static VALUE rb_gsl_linalg_QRPT_Rsvx(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_RLsvx(argc, argv, obj, LINALG_QRPT);
 }
-#ifdef GSL_1_6_LATER
+
 static VALUE rb_gsl_linalg_PTLQ_Lsvx(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_linalg_QRLQPT_RLsvx(argc, argv, obj, LINALG_PTLQ);
 }
-#endif
 
 /*******/
 #ifdef HAVE_NARRAY_H
@@ -2267,11 +2237,11 @@ static VALUE rb_gsl_linalg_SV_decomp(int argc, VALUE *argv, VALUE obj)
       CHECK_VECTOR(argv[1]);
       Data_Get_Struct(argv[1], gsl_vector, w);
       flag = 0;
-      /* no break, do next */
+    /* no break, do next */
     case 1:
 #ifdef HAVE_NARRAY_H
       if (NA_IsNArray(argv[0]))
-	return rb_gsl_linalg_SV_decomp_narray(argc, argv, obj);
+        return rb_gsl_linalg_SV_decomp_narray(argc, argv, obj);
 #endif
       CHECK_MATRIX(argv[0]);
       Data_Get_Struct(argv[0], gsl_matrix, A);
@@ -2318,7 +2288,7 @@ static VALUE rb_gsl_linalg_SV_decomp_mod(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError,
-			    "wrong number of argument (%d for 1)", argc);
+                            "wrong number of argument (%d for 1)", argc);
     CHECK_MATRIX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix, A);
     break;
@@ -2348,10 +2318,10 @@ static VALUE rb_gsl_linalg_SV_decomp_jacobi(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError,
-			    "wrong number of argument (%d for 1)", argc);
+                            "wrong number of argument (%d for 1)", argc);
 #ifdef HAVE_NARRAY_H
-      if (NA_IsNArray(argv[0]))
-	return rb_gsl_linalg_SV_decomp_jacobi_narray(argc, argv, obj);
+    if (NA_IsNArray(argv[0]))
+      return rb_gsl_linalg_SV_decomp_jacobi_narray(argc, argv, obj);
 #endif
     CHECK_MATRIX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix, A);
@@ -2375,7 +2345,7 @@ static VALUE rb_gsl_linalg_SV_solve(int argc, VALUE *argv, VALUE obj)
   gsl_matrix *A = NULL, *U = NULL, *V = NULL;
   gsl_vector *S = NULL, *b = NULL, *x = NULL;
   int flagb = 0, flagv = 0;
-  
+
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc < 1) rb_raise(rb_eArgError, "too few arguments.");
@@ -2386,35 +2356,35 @@ static VALUE rb_gsl_linalg_SV_solve(int argc, VALUE *argv, VALUE obj)
 
     CHECK_MATRIX(argv[0]);
     if (CLASS_OF(argv[0]) == cgsl_matrix_U) {
-      if (argc != 4) rb_raise(rb_eArgError, 
-			      "wrong number of arguments (%d for 4)", argc);
+      if (argc != 4) rb_raise(rb_eArgError,
+                              "wrong number of arguments (%d for 4)", argc);
       Data_Get_Struct(argv[0], gsl_matrix, U);
       CHECK_MATRIX(argv[1]);
-      if (CLASS_OF(argv[1]) != cgsl_matrix_V) 
-	rb_raise(rb_eTypeError, "not a V matrix");
+      if (CLASS_OF(argv[1]) != cgsl_matrix_V)
+        rb_raise(rb_eTypeError, "not a V matrix");
       Data_Get_Struct(argv[1], gsl_matrix, V);
       CHECK_VECTOR(argv[2]);
-      if (CLASS_OF(argv[2]) != cgsl_vector_S) 
-	rb_raise(rb_eTypeError, "not a S vector");
+      if (CLASS_OF(argv[2]) != cgsl_vector_S)
+        rb_raise(rb_eTypeError, "not a S vector");
       Data_Get_Struct(argv[2], gsl_vector, S);
       if (TYPE(argv[3]) == T_ARRAY) {
-	b = make_cvector_from_rarray(argv[3]);
-	flagb = 1;
+        b = make_cvector_from_rarray(argv[3]);
+        flagb = 1;
       } else {
-	CHECK_VECTOR(argv[3]);
-	Data_Get_Struct(argv[3], gsl_vector, b);
+        CHECK_VECTOR(argv[3]);
+        Data_Get_Struct(argv[3], gsl_vector, b);
       }
     } else {
-      if (argc != 2) rb_raise(rb_eArgError, 
-			      "wrong number of arguments (%d for 2)", argc);
+      if (argc != 2) rb_raise(rb_eArgError,
+                              "wrong number of arguments (%d for 2)", argc);
       Data_Get_Struct(argv[0], gsl_matrix, A);
       U = make_matrix_clone(A);
       if (TYPE(argv[1]) == T_ARRAY) {
-	b = make_cvector_from_rarray(argv[1]);
-	flagb = 1;
+        b = make_cvector_from_rarray(argv[1]);
+        flagb = 1;
       } else {
-	CHECK_VECTOR(argv[1]);
-	Data_Get_Struct(argv[1], gsl_vector, b);
+        CHECK_VECTOR(argv[1]);
+        Data_Get_Struct(argv[1], gsl_vector, b);
       }
       S = gsl_vector_alloc(A->size2);   /* see manual p 123 */
       V = gsl_matrix_alloc(A->size2, A->size2);
@@ -2423,8 +2393,8 @@ static VALUE rb_gsl_linalg_SV_solve(int argc, VALUE *argv, VALUE obj)
     }
     break;
   default:
-    if (argc != 1) rb_raise(rb_eArgError, 
-			    "wrong number of arguments (%d for 1)", argc);
+    if (argc != 1) rb_raise(rb_eArgError,
+                            "wrong number of arguments (%d for 1)", argc);
     Data_Get_Struct(obj, gsl_matrix, A);
     U = make_matrix_clone(A);
     if (TYPE(argv[0]) == T_ARRAY) {
@@ -2440,7 +2410,7 @@ static VALUE rb_gsl_linalg_SV_solve(int argc, VALUE *argv, VALUE obj)
     flagv = 1;
     break;
   }
-  //  x = gsl_vector_alloc(b->size);  
+  //  x = gsl_vector_alloc(b->size);
   // Bug report #25842
   x = gsl_vector_alloc(S->size);
   gsl_linalg_SV_solve(U, V, S, b, x);
@@ -2487,8 +2457,8 @@ static VALUE rb_gsl_linalg_cholesky_solve_narray(int argc, VALUE *argv, VALUE ob
     x = argv[2];
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "Usage: Cholesky.solve(chol, b) or Cholesky.solve(chol, b, x)");
+    rb_raise(rb_eArgError,
+             "Usage: Cholesky.solve(chol, b) or Cholesky.solve(chol, b, x)");
     break;
   }
   mv = gsl_matrix_view_array((double*)nm->ptr, nm->shape[1], nm->shape[0]);
@@ -2518,7 +2488,7 @@ static VALUE rb_gsl_linalg_cholesky_decomp(int argc, VALUE *argv, VALUE obj)
   switch(TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_cholesky_decomp_narray(argc, argv, obj);
@@ -2545,7 +2515,7 @@ static VALUE rb_gsl_linalg_cholesky_solve(int argc, VALUE *argv, VALUE obj)
   switch(TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)",
-			    argc);
+                            argc);
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_cholesky_solve_narray(argc, argv, obj);
@@ -2555,7 +2525,7 @@ static VALUE rb_gsl_linalg_cholesky_solve(int argc, VALUE *argv, VALUE obj)
     break;
   default:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
     vA = obj;
     vb = argv[0];
     break;
@@ -2593,7 +2563,7 @@ static VALUE rb_gsl_linalg_cholesky_svx(int argc, VALUE *argv, VALUE obj)
   switch(TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)",
-			    argc);
+                            argc);
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(argv[0]))
       return rb_gsl_linalg_cholesky_svx_narray(argc, argv, obj);
@@ -2603,7 +2573,7 @@ static VALUE rb_gsl_linalg_cholesky_svx(int argc, VALUE *argv, VALUE obj)
     break;
   default:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
     vA = obj;
     vb = argv[0];
     break;
@@ -2632,7 +2602,7 @@ static VALUE rb_gsl_linalg_symmtd_decomp(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
     CHECK_MATRIX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix, Atmp);
     break;
@@ -2657,7 +2627,7 @@ static VALUE rb_gsl_linalg_symmtd_decomp2(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
     CHECK_MATRIX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix, A);
     break;
@@ -2679,14 +2649,14 @@ static VALUE rb_gsl_linalg_symmtd_unpack(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)",
-			    argc);
+                            argc);
     CHECK_MATRIX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix, A);
     Data_Get_Struct(argv[1], gsl_vector, tau);
     break;
   default:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
     CHECK_MATRIX(obj);
     Data_Get_Struct(obj, gsl_matrix, A);
     Data_Get_Struct(argv[0], gsl_vector, tau);
@@ -2712,7 +2682,7 @@ static VALUE rb_gsl_linalg_symmtd_unpack_T(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)",
-			    argc);
+                            argc);
     CHECK_MATRIX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix, A);
     break;
@@ -2740,7 +2710,7 @@ static VALUE rb_gsl_linalg_hermtd_decomp(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",
-			    argc);
+                            argc);
     CHECK_MATRIX_COMPLEX(argv[0]);
     Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp);
     break;
@@ -2764,7 +2734,7 @@ static VALUE rb_gsl_linalg_hermtd_decomp2(int argc, VALUE *argv, VALUE obj)
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)",