gsl 1.15.3 → 1.16.0.6

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

@@ -2,18 +2,16 @@
   matrix_double.c
   Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
     (C) Copyright 2001-2006 by Yoshiki Tsunesada
-  
+
   Ruby/GSL is free software: you can redistribute it and/or modify it
   under the terms of the GNU General Public License.
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_array.h"
-#include "rb_gsl_complex.h"
-#ifdef HAVE_NARRAY_H
-#include "rb_gsl_with_narray.h"
-#endif
+
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_complex.h"
+#include "include/rb_gsl_with_narray.h"
 
 enum {
   GSL_MATRIX_ADD,
@@ -62,29 +60,28 @@ static VALUE rb_gsl_matrix_arithmetics(int flag, VALUE obj, VALUE bb)
   default:
     if (MATRIX_INT_P(bb)) bb = rb_gsl_matrix_int_to_f(bb);
     if (VECTOR_INT_P(bb)) bb = rb_gsl_vector_int_to_f(bb);
-
     if (rb_obj_is_kind_of(bb, cgsl_matrix)) {
       Data_Get_Struct(bb, gsl_matrix, mb);
       switch (flag) {
       case GSL_MATRIX_ADD:
-	mnew = make_matrix_clone(m);
-	gsl_matrix_add(mnew, mb);
-	break;
+        mnew = make_matrix_clone(m);
+        gsl_matrix_add(mnew, mb);
+        break;
       case GSL_MATRIX_SUB:
-	mnew = make_matrix_clone(m);
-	gsl_matrix_sub(mnew,mb);
-	break;
+        mnew = make_matrix_clone(m);
+        gsl_matrix_sub(mnew,mb);
+        break;
       case GSL_MATRIX_MUL:
-	mnew = make_matrix_clone(m);
-	gsl_matrix_mul_elements(mnew, mb);
-	break;
+        mnew = make_matrix_clone(m);
+        gsl_matrix_mul_elements(mnew, mb);
+        break;
       case GSL_MATRIX_DIV:
-	mnew = make_matrix_clone(m);
-	gsl_matrix_div_elements(mnew, mb);
-	break;
+        mnew = make_matrix_clone(m);
+        gsl_matrix_div_elements(mnew, mb);
+        break;
       default:
-	rb_raise(rb_eRuntimeError, "operation not defined");
-	break;
+        rb_raise(rb_eRuntimeError, "operation not defined");
+        break;
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else if (rb_obj_is_kind_of(bb, cgsl_matrix_complex)) {
@@ -92,20 +89,20 @@ static VALUE rb_gsl_matrix_arithmetics(int flag, VALUE obj, VALUE bb)
       cmnew = matrix_to_complex(m);
       switch (flag) {
       case GSL_MATRIX_ADD:
-	gsl_matrix_complex_add(cmnew, cmb);
-	break;
+        gsl_matrix_complex_add(cmnew, cmb);
+        break;
       case GSL_MATRIX_SUB:
-	gsl_matrix_complex_sub(cmnew,cmb);
-	break;
+        gsl_matrix_complex_sub(cmnew,cmb);
+        break;
       case GSL_MATRIX_MUL:
-	gsl_matrix_complex_mul_elements(cmnew, cmb);
-	break;
+        gsl_matrix_complex_mul_elements(cmnew, cmb);
+        break;
       case GSL_MATRIX_DIV:
-	gsl_matrix_complex_div_elements(cmnew, cmb);
-	break;
+        gsl_matrix_complex_div_elements(cmnew, cmb);
+        break;
       default:
-	rb_raise(rb_eRuntimeError, "operation not defined");
-	break;
+        rb_raise(rb_eRuntimeError, "operation not defined");
+        break;
       }
       return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew);
     } else if (rb_obj_is_kind_of(bb, cgsl_complex)) {
@@ -113,60 +110,60 @@ static VALUE rb_gsl_matrix_arithmetics(int flag, VALUE obj, VALUE bb)
       cmnew = matrix_to_complex(m);
       switch (flag) {
       case GSL_MATRIX_ADD:
-	gsl_matrix_complex_add_constant(cmnew, *c);
-	break;
+        gsl_matrix_complex_add_constant(cmnew, *c);
+        break;
       case GSL_MATRIX_SUB:
-	gsl_matrix_complex_add_constant(cmnew, gsl_complex_negative(*c));
-	break;
+        gsl_matrix_complex_add_constant(cmnew, gsl_complex_negative(*c));
+        break;
       case GSL_MATRIX_MUL:
-	gsl_matrix_complex_scale(cmnew, *c);
-	break;
+        gsl_matrix_complex_scale(cmnew, *c);
+        break;
       case GSL_MATRIX_DIV:
-	gsl_matrix_complex_scale(cmnew, gsl_complex_inverse(*c));
-	break;
+        gsl_matrix_complex_scale(cmnew, gsl_complex_inverse(*c));
+        break;
       default:
-	rb_raise(rb_eRuntimeError, "operation not defined");
-	break;
+        rb_raise(rb_eRuntimeError, "operation not defined");
+        break;
       }
       return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew);
     } else if (rb_obj_is_kind_of(bb, cgsl_vector)) {
       if (!VECTOR_COL_P(bb))
-	rb_raise(rb_eTypeError, 
-		 "Operation with %s is not defined (GSL::Vector::Col expected)", 
-		 rb_class2name(CLASS_OF(bb)));
+        rb_raise(rb_eTypeError,
+                 "Operation with %s is not defined (GSL::Vector::Col expected)",
+                 rb_class2name(CLASS_OF(bb)));
       Data_Get_Struct(bb, gsl_vector, v);
       switch (flag) {
       case GSL_MATRIX_MUL:
-	//	vnew = gsl_vector_alloc(v->size);
-	vnew = gsl_vector_alloc(m->size1);
-	if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed");
-	gsl_matrix_mul_vector(vnew, m, v);
-	return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, vnew);
-	break;
+        //  vnew = gsl_vector_alloc(v->size);
+        vnew = gsl_vector_alloc(m->size1);
+        if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed");
+        gsl_matrix_mul_vector(vnew, m, v);
+        return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, vnew);
+        break;
       case GSL_MATRIX_DIV:
-	return rb_gsl_linalg_LU_solve(1, &bb, obj);
-	break;
+        return rb_gsl_linalg_LU_solve(1, &bb, obj);
+        break;
       default:
-	rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix",
-		 rb_class2name(CLASS_OF(bb)));
-	break;
+        rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix",
+                 rb_class2name(CLASS_OF(bb)));
+        break;
       }
     } else if (rb_obj_is_kind_of(bb, cgsl_vector_complex)) {
       Data_Get_Struct(bb, gsl_vector_complex, cv);
       switch (flag) {
       case GSL_MATRIX_MUL:
-	cm = matrix_to_complex(m);
-	//	cvnew = gsl_vector_complex_alloc(cv->size);
-	cvnew = gsl_vector_complex_alloc(m->size1);
-	if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed");
-	gsl_matrix_complex_mul_vector(cvnew, cm, cv);
-	gsl_matrix_complex_free(cm);
-	return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew);
-	break;
+        cm = matrix_to_complex(m);
+        //  cvnew = gsl_vector_complex_alloc(cv->size);
+        cvnew = gsl_vector_complex_alloc(m->size1);
+        if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed");
+        gsl_matrix_complex_mul_vector(cvnew, cm, cv);
+        gsl_matrix_complex_free(cm);
+        return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew);
+        break;
       default:
-	rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix",
-		 rb_class2name(CLASS_OF(bb)));
-	break;
+        rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix",
+                 rb_class2name(CLASS_OF(bb)));
+        break;
       }
     } else {
       rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(bb)));
@@ -236,8 +233,8 @@ static VALUE rb_gsl_matrix_mul(VALUE obj, VALUE bb)
       return rb_gsl_matrix_mul_elements(obj, bb);
       break;
     default:
-      rb_raise(rb_eTypeError, 
-	       "wrong argument type %s", rb_class2name(CLASS_OF(bb)));
+      rb_raise(rb_eTypeError,
+               "wrong argument type %s", rb_class2name(CLASS_OF(bb)));
       break;
     }
   }
@@ -271,8 +268,8 @@ static VALUE rb_gsl_matrix_mul_bang(VALUE obj, VALUE bb)
       return obj;
       break;
     default:
-      rb_raise(rb_eTypeError, 
-	       "wrong argument type %s", rb_class2name(CLASS_OF(bb)));
+      rb_raise(rb_eTypeError,
+               "wrong argument type %s", rb_class2name(CLASS_OF(bb)));
       break;
     }
   }
@@ -336,8 +333,8 @@ static VALUE rb_gsl_matrix_coerce(VALUE obj, VALUE other)
       vcm = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cm);
       return rb_ary_new3(2, other, vcm);
     } else {
-      rb_raise(rb_eTypeError, "cannot coerce %s to Matrix", 
-	       rb_class2name(CLASS_OF(other)));
+      rb_raise(rb_eTypeError, "cannot coerce %s to Matrix",
+               rb_class2name(CLASS_OF(other)));
     }
     break;
   }
@@ -384,7 +381,7 @@ static VALUE rb_gsl_matrix_clean(int argc, VALUE *argv, VALUE obj)
   mnew = make_matrix_clone(m);
   n = m->size1*m->size2;
   for (i = 0; i < n; i++) if (fabs(mnew->data[i]) < eps) mnew->data[i] = 0.0;
-  return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);;
+  return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
 }
 
 static VALUE rb_gsl_matrix_clean_bang(int argc, VALUE *argv, VALUE obj)
@@ -411,8 +408,8 @@ static VALUE rb_gsl_matrix_clean_bang(int argc, VALUE *argv, VALUE obj)
 }
 
 
-static VALUE rb_gsl_matrix_op_inplace(VALUE mm1, VALUE mm2, 
-				      int (*f)(gsl_matrix*, const gsl_matrix*))
+static VALUE rb_gsl_matrix_op_inplace(VALUE mm1, VALUE mm2,
+                                      int (*f)(gsl_matrix*, const gsl_matrix*))
 {
   gsl_matrix *m1, *m2;
   Data_Get_Struct(mm1, gsl_matrix, m1);
@@ -465,9 +462,9 @@ static VALUE rb_gsl_matrix_log10(VALUE obj)
 
 #include <gsl/gsl_rng.h>
 #include <gsl/gsl_randist.h>
-#include "rb_gsl_rng.h"
+#include "include/rb_gsl_rng.h"
 static VALUE rb_gsl_matrix_randx(int argc, VALUE *argv, VALUE klass,
-				 double (*f)(const gsl_rng*));
+                                 double (*f)(const gsl_rng*));
 static VALUE rb_gsl_matrix_rand(int argc, VALUE *argv, VALUE klass)
 {
   return rb_gsl_matrix_randx(argc, argv, klass, gsl_rng_uniform);
@@ -479,7 +476,7 @@ static VALUE rb_gsl_matrix_randn(int argc, VALUE *argv, VALUE klass)
 }
 
 static VALUE rb_gsl_matrix_randx(int argc, VALUE *argv, VALUE klass,
-				 double (*f)(const gsl_rng*))
+                                 double (*f)(const gsl_rng*))
 {
   gsl_matrix *m;
   gsl_rng *rng;
@@ -488,8 +485,8 @@ static VALUE rb_gsl_matrix_randx(int argc, VALUE *argv, VALUE klass,
   switch (argc) {
   case 3:
     if (!rb_obj_is_kind_of(argv[2], cgsl_rng)) {
-      rb_raise(rb_eTypeError, 
-	       "Wrong argument type (GSL::Rng expected)");
+      rb_raise(rb_eTypeError,
+               "Wrong argument type (GSL::Rng expected)");
     }
     Data_Get_Struct(argv[2], gsl_rng, rng);
     size1 = FIX2INT(argv[0]);
@@ -530,7 +527,7 @@ void Init_gsl_matrix(VALUE module)
   rb_define_alias(cgsl_matrix, "*", "mul");
   rb_define_method(cgsl_matrix, "mul!", rb_gsl_matrix_mul_bang, 1);
   /***/
- 
+
   rb_define_method(cgsl_matrix, "to_complex", rb_gsl_matrix_to_complex, 0);
 
   rb_define_method(cgsl_matrix, "coerce", rb_gsl_matrix_coerce, 1);

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

@@ -2,21 +2,21 @@
   matrix_int.c
   Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
     (C) Copyright 2001-2006 by Yoshiki Tsunesada
-  
+
   Ruby/GSL is free software: you can redistribute it and/or modify it
   under the terms of the GNU General Public License.
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_array.h"
-#include "rb_gsl_complex.h"
+
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_complex.h"
 #ifdef HAVE_NARRAY_H
-#include "rb_gsl_with_narray.h"
+#include "include/rb_gsl_with_narray.h"
 #endif
 
-int gsl_linalg_matmult_int(const gsl_matrix_int *A, 
-			   const gsl_matrix_int *B, gsl_matrix_int *C);
+int gsl_linalg_matmult_int(const gsl_matrix_int *A,
+                           const gsl_matrix_int *B, gsl_matrix_int *C);
 
 
 VALUE rb_gsl_matrix_to_i(VALUE obj);
@@ -85,16 +85,16 @@ static VALUE rb_gsl_matrix_int_operation1(VALUE obj, VALUE other, int flag)
     bval = NUM2INT(other);
     anew = make_matrix_int_clone(a);
     switch (flag) {
-    case GSL_MATRIX_INT_ADD: 
+    case GSL_MATRIX_INT_ADD:
       /*result =*/ gsl_matrix_int_add_constant(anew, bval);
       break;
-    case GSL_MATRIX_INT_SUB: 
+    case GSL_MATRIX_INT_SUB:
       /*result =*/ gsl_matrix_int_add_constant(anew, -bval);
       break;
-    case GSL_MATRIX_INT_MUL: 
+    case GSL_MATRIX_INT_MUL:
       /*result =*/ gsl_matrix_int_scale(anew, bval);
       break;
-    case GSL_MATRIX_INT_DIV: 
+    case GSL_MATRIX_INT_DIV:
       /*result =*/ gsl_matrix_int_scale(anew, 1.0/bval);
       break;
     default:
@@ -109,34 +109,34 @@ static VALUE rb_gsl_matrix_int_operation1(VALUE obj, VALUE other, int flag)
       Data_Get_Struct(other, gsl_matrix_int, b);
       switch (flag) {
       case GSL_MATRIX_INT_ADD:
-	/*result =*/ gsl_matrix_int_add(anew, b);
-	break;
+        /*result =*/ gsl_matrix_int_add(anew, b);
+        break;
       case GSL_MATRIX_INT_SUB:
-	/*result =*/ gsl_matrix_int_sub(anew, b);
-	break;
+        /*result =*/ gsl_matrix_int_sub(anew, b);
+        break;
       case GSL_MATRIX_INT_MUL:
-	/*result =*/ gsl_matrix_int_mul_elements(anew, b);
-	break;
+        /*result =*/ gsl_matrix_int_mul_elements(anew, b);
+        break;
       case GSL_MATRIX_INT_DIV:
-	/*result =*/ gsl_matrix_int_div_elements(anew, b);
-	break;
+        /*result =*/ gsl_matrix_int_div_elements(anew, b);
+        break;
       default:
-	break;
+        break;
       }
     } else if (VECTOR_INT_COL_P(other)) {
       switch (flag) {
       case GSL_MATRIX_INT_MUL:
-	Data_Get_Struct(other, gsl_vector_int, vi);
-	vinew = gsl_vector_int_alloc(vi->size);
-	gsl_matrix_int_mul_vector(vinew, a, vi);
-	return Data_Wrap_Struct(cgsl_vector_int_col, 0, gsl_vector_int_free, vinew);
-	break;
+        Data_Get_Struct(other, gsl_vector_int, vi);
+        vinew = gsl_vector_int_alloc(vi->size);
+        gsl_matrix_int_mul_vector(vinew, a, vi);
+        return Data_Wrap_Struct(cgsl_vector_int_col, 0, gsl_vector_int_free, vinew);
+        break;
       default:
-	rb_raise(rb_eRuntimeError, "Operation not defined");
+        rb_raise(rb_eRuntimeError, "Operation not defined");
       }
     } else {
       rb_raise(rb_eTypeError, "Operation not defined with %s",
-	       rb_class2name(CLASS_OF(other)));
+               rb_class2name(CLASS_OF(other)));
     }
     break;
   }
@@ -183,48 +183,47 @@ static VALUE rb_gsl_matrix_int_matrix_mul(VALUE obj, VALUE bb)
     switch (TYPE(bb)) {
     case T_FIXNUM:
       return rb_gsl_matrix_int_mul(obj, bb);
-	/*      return rb_gsl_matrix_int_power(obj, bb);*/
+      /*      return rb_gsl_matrix_int_power(obj, bb);*/
       break;
     default:
       rb_raise(rb_eTypeError, "wrong argument type %s (Matrix::Int, Vector::Int::Col or Fixnum expected)",
-	       rb_class2name(CLASS_OF(bb)));
+               rb_class2name(CLASS_OF(bb)));
       break;
     }
   }
 }
 
-int gsl_linalg_matmult_int(const gsl_matrix_int *A, 
-			   const gsl_matrix_int *B, gsl_matrix_int *C)
+int gsl_linalg_matmult_int(const gsl_matrix_int *A,
+                           const gsl_matrix_int *B, gsl_matrix_int *C)
 {
   if (A->size2 != B->size1 || A->size1 != C->size1 || B->size2 != C->size2)
-    {
-      GSL_ERROR ("matrix sizes are not conformant", GSL_EBADLEN);
-    }
+  {
+    GSL_ERROR ("matrix sizes are not conformant", GSL_EBADLEN);
+  }
   else
+  {
+    int a, b;
+    int temp;
+    size_t i, j, k;
+
+    for (i = 0; i < C->size1; i++)
     {
-      int a, b;
-      int temp;
-      size_t i, j, k;
-      
-      for (i = 0; i < C->size1; i++)
+      for (j = 0; j < C->size2; j++)
+      {
+        a = gsl_matrix_int_get(A, i, 0);
+        b = gsl_matrix_int_get(B, 0, j);
+        temp = a * b;
+        for (k = 1; k < A->size2; k++)
         {
-          for (j = 0; j < C->size2; j++)
-            {
-              a = gsl_matrix_int_get(A, i, 0);
-              b = gsl_matrix_int_get(B, 0, j);
-              temp = a * b;
-              for (k = 1; k < A->size2; k++)
-                {
-                  a = gsl_matrix_int_get(A, i, k);
-                  b = gsl_matrix_int_get(B, k, j);
-                  temp += a * b;
-                }
-              gsl_matrix_int_set(C, i, j, temp);
-            }
+          a = gsl_matrix_int_get(A, i, k);
+          b = gsl_matrix_int_get(B, k, j);
+          temp += a * b;
         }
-
-      return GSL_SUCCESS;
+        gsl_matrix_int_set(C, i, j, temp);
+      }
     }
+    return GSL_SUCCESS;
+  }
 }
 
 void Init_gsl_matrix_int_init(VALUE module);