tioga 1.11 → 1.13

data/Tioga_README

@@ -1,7 +1,8 @@
 This is the README for the Tioga kernel, version 1.10, March 7, 2009.
 
     Copyright (C) 2005, 2006, 2007, 2008, 2009  Bill Paxton
-    Copyright (C) 2007, 2008, 2009 Vincent Fourmond, Taro Sato
+    Copyright (C) 2007, 2008, 2009, 2010 Vincent Fourmond, Taro Sato, 
+    	      	  Benjamin ter Kuile
     
     This file is part of Tioga.
     
@@ -21,16 +22,13 @@ This is the README for the Tioga kernel, version 1.10, March 7, 2009.
 
 << What's new >>
 
-    Version 1.11 brings in a few new features. First, it is now
-possible to set the color of axis tick labels - if you love pink axes,
-you can them fully in Pink, now ;-) ! Check out the
-x/yaxis_labels_color= accessors. The show_axis/axis_info functions
-have been updated accordingly, and are now complete.
-
-    Second, a new interpolation function for monotonic interpolations
-has been added to Dvector (check out the Sampled_pm_cubics sample in
-samples/plots/plots.rb).
+   Tioga 1.13 brings in a fix for a well-hidden memory leak that was
+unlikely to hit you unless you were allocating a huge number of
+vectors.
 
+   More interestingly, a few instance functions that did not depend on
+FigureMaker's internal state (color conversion functions and
+contouring algorithms) were made available as module functions too.
 
 << Quick Installation of Tioga >>
 
@@ -56,41 +54,27 @@ be working, go directly to the << Documentation >> section below.
 << Step-by-Step Installation >>
 
     To get Tioga running, you need to have a working Ruby, a C
-compiler, make, and pdflaxtex.  Assuming you've got all that (more
+compiler, make, and pdflatex.  Assuming you've got all that (more
 later if you don't), connect to the Tioga directory that you just
 unpacked and do the following:
 
   [ this has been changed, be careful ! ]
 
-    cd split 
-    ruby extconf.rb
-    make
-    make install
+    ruby setup.rb config
+    ruby setup.rb seutp
+    ruby setup.rb install
 
-This creates the Makefile, runs it, and finally does the actual
-installation.  The "make install" needs to copy some files to the ruby
-directory.  On the Mac, this probably means you need to do the whole
-thing inside a 'sudo'.  For Linux, you may have to become root.
+    (that's exactly what the ./QUICK_INSTALL script is doing)
 
-Note that on Linux, the make will compile all the source files.  On
-the Mac, the tar file includes precompiled versions of everything, so
-the make won't have anything to do.  That's okay.  Do the whole
-sequence anyway just to be safe.
-
-    You now have another option to install: if you replace the line
-
-    ruby extconf.rb
-
-with 
-
-    ruby extconf.rb --home
-
-it will install the files to your home directory, namely
-~/lib/ruby. You don't need root privileges to do that, but make sure
-that you set RUBYLIB=~/lib/ruby somewhere, so that ruby can find it.
+    Tioga now uses the standard setup.rb installation tool, so you get
+a lot of customization possibilities for free. For more information on
+how to use setup.rb to suit your needs, try
 
+    ruby setup.rb --help
 
+or, even better, take a look at its documentation:
 
+http://i.loveruby.net/en/projects/setup/doc/usage.html
 
 << Checking The Installation >>
 
@@ -188,6 +172,45 @@ Bill Paxton
 
 Here are the old release messages:
 
+    Tioga 1.12 has seen quite a lot of action. The first and major
+change is the switch from a custom rewrite of mkmf.rb for
+building/installing to the standard setup.rb tool, which finally has
+the gem version build exactly the same way as the pristine one.
+
+    Another side effect of this is that, for a big part thanks to
+Carlo E. Prelz <fluido@fluido.as>, we now have tioga that works just
+fine with Ruby 1.9.1 (though there is a weird bug while testing the
+Flate library, we welcome any input on that).
+
+    Apart from that, Tioga has seen many improvements on the numerical
+side. First, we welcome the participation of Benjamin ter Kuile, who
+has started improving some aspects of Dtable.
+
+    Second, now Dvector is gifted with FFT capacities if the
+development files of fftw3 are available at compile time (have a look
+at the documentation).
+
+    Third, Function has been endowed with a whole bunch of new
+functions for data processing, such as linear regression, spline
+approximation (that almost looks like a good filter !), 4th order
+accurate first and second derivatives.
+
+    Finally, a couple of annoying bugs were fixed.
+
+
+--------------------------
+
+    Version 1.11 brings in a few new features. First, it is now
+possible to set the color of axis tick labels - if you love pink axes,
+you can them fully in Pink, now ;-) ! Check out the
+x/yaxis_labels_color= accessors. The show_axis/axis_info functions
+have been updated accordingly, and are now complete.
+
+    Second, a new interpolation function for monotonic interpolations
+has been added to Dvector (check out the Sampled_pm_cubics sample in
+samples/plots/plots.rb).
+
+
 --------------------------
 
     Version 1.10 is a minor bug-fix release, the most important one

data/{split/scripts → bin}/tioga

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#! /usr/bin/ruby1.8
 require 'Tioga/tioga_ui.rb'
 
 

data/{split → ext/Dobjects}/Dtable/dtable.c

@@ -25,15 +25,16 @@
 #include <stdlib.h>
 #include <ctype.h>
 #include <math.h>
-#include "intern.h"
 
-#include "../symbols.h"
-#include "../symbols.c"
+/* Internal include files, from the ext/includes directory */
+#include <symbols.h>
+#include <symbols.c>
 
 #include <defs.h>
 
 /* safe storing of doubles */
 #include <safe_double.h>
+/* End of internal files */
 
 
 #define is_a_dtable(d) ( TYPE(d) == T_DATA && RDATA(d)->dfree == (RUBY_DATA_FUNC)dtable_free )
@@ -406,7 +407,7 @@ PRIVATE
    row_num = rb_Integer(row_num);
    int row = NUM2INT(row_num);
    if (row < 0 || row >= d->num_rows)
-      rb_raise(rb_eArgError, "Asking for row i = %i from array with only %i rows", row, d->num_rows);
+      rb_raise(rb_eArgError, "Asking for row i = %i from array with only %li rows", row, d->num_rows);
    VALUE dvec = Dvector_Create();
    Dvector_Data_Replace(dvec, d->num_cols, d->ptr[row]);
    return dvec;
@@ -426,14 +427,31 @@ PRIVATE
    row_num = rb_Integer(row_num);
    int row = NUM2INT(row_num);
    if (row < 0 || row >= d->num_rows)
-      rb_raise(rb_eArgError, "Asking for row i = %i from array with only %i rows", row, d->num_rows);
+      rb_raise(rb_eArgError, "Asking for row i = %i from array with only %li rows", row, d->num_rows);
    if (len != d->num_cols)
-      rb_raise(rb_eArgError, "Length of vector (%i) does not match number of columns (%i)", len, d->num_cols);
+      rb_raise(rb_eArgError, "Length of vector (%li) does not match number of columns (%li)", len, d->num_cols);
    for (j=0; j < len; j++)
       d->ptr[row][j] = data[j];
    return dvec;
 }
 
+PRIVATE
+/*
+ *  call-seq:
+ *    dtable.each_row{|row| }
+ *
+ *  Iterates over all rows and executes the given block
+ */ VALUE dtable_each_row(VALUE ary){
+   Dtable *d = Get_Dtable(ary);
+   VALUE dvec = Dvector_Create();
+   int i;
+   for(i=0; i < d->num_rows; i++){
+     Dvector_Data_Replace(dvec, d->num_cols, d->ptr[i]);
+     rb_yield(dvec);
+   }
+   return ary;
+}
+
 PRIVATE
 /*
  *  call-seq:
@@ -448,9 +466,9 @@ PRIVATE
    col_num = rb_Integer(col_num);
    int col = NUM2INT(col_num);
    if (col < 0 || col >= d->num_cols)
-      rb_raise(rb_eArgError, "Asking for column i = %i from array with only %i columns", col, d->num_cols);
+      rb_raise(rb_eArgError, "Asking for column i = %i from array with only %li columns", col, d->num_cols);
    if (len != d->num_rows)
-      rb_raise(rb_eArgError, "Length of vector (%i) does not match number of rows (%i)", len, d->num_rows);
+      rb_raise(rb_eArgError, "Length of vector (%li) does not match number of rows (%li)", len, d->num_rows);
    for (i=0; i < len; i++)
       d->ptr[i][col] = data[i];
    return dvec;
@@ -467,7 +485,7 @@ PRIVATE
    column_num = rb_Integer(column_num);
    int i, column = NUM2INT(column_num), len;
    if (column < 0 || column >= d->num_cols)
-      rb_raise(rb_eArgError, "Asking for column i = %i from array with only %i columns", column, d->num_cols);
+      rb_raise(rb_eArgError, "Asking for column i = %i from array with only %li columns", column, d->num_cols);
    VALUE dvec = Dvector_Create();
    len = d->num_rows;
    Dvector_Data_Resize(dvec, len);
@@ -476,6 +494,25 @@ PRIVATE
    return dvec;
 }
 
+PRIVATE
+/*
+ *  call-seq:
+ *    dtable.each_column{|col| }
+ *
+ *  Iterates over all columns and executes the given block
+ */ VALUE dtable_each_column(VALUE ary){
+   Dtable *d = Get_Dtable(ary);
+   VALUE dvec = Dvector_Create();
+   int i,j;
+   for(j=0; j < d->num_cols; j++){
+     for(i=0; i < d->num_rows; i++){
+       Dvector_Store_Double(dvec, i, d->ptr[i][j]);
+     }
+     rb_yield(dvec);
+   }
+   return ary;
+}
+
 static void set_dtable_vals(VALUE ary, double v) {
    Dtable *d = Get_Dtable(ary);
    int num_cols = d->num_cols, num_rows = d->num_rows, i, j;
@@ -1576,7 +1613,7 @@ PRIVATE
             printf("len %i\n", len);
             strncpy(err_str,buff,len);
             rb_raise(rb_eArgError,
-               "failed to read requested amount of data in %s (asked for %i xs and %i ys; found only %i and %i). last attempt to read got %g from string starting with: %s",
+               "failed to read requested amount of data in %s (asked for %li xs and %li ys; found only %i and %i). last attempt to read got %g from string starting with: %s",
                filename, num_cols, num_rows, i+1, j, data[j], err_str);
          }
       }
@@ -1759,13 +1796,13 @@ PRIVATE
    Dtable *d = Get_Dtable(ary);
 	int nx = NUM2DBL(rb_Integer(nx_val));
 	int ny = NUM2DBL(rb_Integer(ny_val));
-   int i, j, num_cols = d->num_cols, num_rows = d->num_rows, last_row = num_rows - 1;
+	int i, j, num_cols = d->num_cols, num_rows = d->num_rows/*, last_row = num_rows - 1*/;
 	
    long xsrc_len, ysrc_len;
    double *xsrc = Dvector_Data_for_Read(x_vec, &xsrc_len);
    double *ysrc = Dvector_Data_for_Read(y_vec, &ysrc_len);
-	if(xsrc_len != num_cols) rb_raise(rb_eArgError, "Number of x values (%d) do not match the number of columns (%d)", xsrc_len, num_cols);
-	if(ysrc_len != num_rows) rb_raise(rb_eArgError, "Number of y values (%d) do not match the number of rows (%d)", ysrc_len, num_rows);
+	if(xsrc_len != num_cols) rb_raise(rb_eArgError, "Number of x values (%ld) do not match the number of columns (%d)", xsrc_len, num_cols);
+	if(ysrc_len != num_rows) rb_raise(rb_eArgError, "Number of y values (%ld) do not match the number of rows (%d)", ysrc_len, num_rows);
    VALUE new = dtable_init(dtable_alloc(cDtable), nx, ny);
    Dtable *d2 = Get_Dtable(new);
    double **src, **dest;
@@ -1811,6 +1848,34 @@ PRIVATE
    return new;
 }
 
+PRIVATE 
+/*
+ *  call-seq:
+ *     dtable.sum   ->  number
+ *  
+ *  Returns the sum of the entries in _dtable_. Returns 0.0 if
+ *  _dtable_ is empty.
+ *     
+ *     a = Dtable.new(2,4)
+ *     a.set_column(0, Dvector[1,2,3,4])
+ *     a.set_column(1, Dvector[0, 1, 0, 1])
+ *     a.sum        -> 12.0
+ *     Dtable.new(2,2).sum   -> 0.0
+ */ 
+VALUE dtable_sum(VALUE tabl){
+  int i,j;
+  double sum=0.0;
+  double **src;
+  Dtable *d = Get_Dtable(tabl);
+  src = d->ptr; 
+  for(i=0; i < d->num_cols; i++){
+    for(j=0; j < d->num_rows; j++){
+      sum = sum + src[j][i];
+    }
+  }
+  return rb_float_new(sum);
+}
+
 /* 
  * Document-class: Dobjects::Dtable
  *
@@ -1819,8 +1884,6 @@ PRIVATE
  * Essentially any of the operations you might do with a Ruby Array of numbers can also be done with a Dtable.
  * Dtables follow the same design philosophy as Dvector and uses Dvectors for several operations.
  */
-
-
 PUBLIC void Init_Dtable() {
    /* modified by Vincent Fourmond, for splitting out the libraries */
   
@@ -1968,6 +2031,9 @@ PUBLIC void Init_Dtable() {
    rb_define_method(cDtable, "safe_acos!", dtable_safe_acos_bang, 0);
 
    rb_define_method(cDtable, "interpolate", dtable_interpolate, 8);
+   rb_define_method(cDtable, "sum", dtable_sum, 0);
+   rb_define_method(cDtable, "each_row", dtable_each_row, 0);
+   rb_define_method(cDtable, "each_column", dtable_each_column, 0);
 
    /* Marshal : */
    rb_define_method(cDtable, "_dump", dtable_dump, 1);

data/ext/Dobjects/Dtable/extconf.rb

@@ -0,0 +1,7 @@
+# Dtable installation file
+require 'mkmf'
+
+# We add include directories
+$INCFLAGS += " -I../../includes -I../Dvector/include"
+
+create_makefile 'Dobjects/Dtable'

data/{split → ext/Dobjects}/Dvector/dvector.c

@@ -27,11 +27,12 @@
 #include <ctype.h>
 #include <math.h>
 #include "ruby.h"
-#include "intern.h"
 #include "dvector_intern.h"
 
-#include "../symbols.h"
-#include "../symbols.c"
+
+/* Internal files that are defined in the ext/includes directory */
+#include <symbols.h>
+#include <symbols.c>
 
 /* compiler-dependent definitions, such as is_okay_number */
 #include <defs.h>
@@ -39,8 +40,8 @@
 /* safe storing of doubles */
 #include <safe_double.h>
 
-/* temp */
-/* #include <stdio.h> */
+/* End of internal files */
+
 #define is_a_dvector(d) ( TYPE(d) == T_DATA && RDATA(d)->dfree == (RUBY_DATA_FUNC)dvector_free )
 
 #ifndef MAX
@@ -119,8 +120,8 @@ static VALUE dvector_alloc(VALUE klass) {
    Dvector *d;
    VALUE ary = Data_Make_Struct(klass, Dvector, dvector_mark, dvector_free, d);
    d->len = 0;
-   d->ptr = ALLOC_N(double, 1);
-   d->capa = 1;
+   d->ptr = NULL;
+   d->capa = 0;
    d->shared = Qnil;
    return ary;
 }
@@ -187,7 +188,7 @@ static void dvector_store(VALUE ary, long idx, VALUE val) {
 static VALUE dvector_to_dvector(VALUE obj) {
    if ( is_a_dvector(obj) ) return obj;
    obj = rb_Array(obj);
-   return dvector_s_create(RARRAY(obj)->len, RARRAY(obj)->ptr, cDvector);
+   return dvector_s_create(RARRAY_LEN(obj), RARRAY_PTR(obj), cDvector);
 }
 
 static Dvector *Get_Dvector(VALUE obj) {
@@ -910,7 +911,7 @@ static void dvector_splice(VALUE ary, long beg, long len, VALUE rpl) {
       rlen = 0;
    } else if (rb_obj_is_kind_of(rpl,rb_cArray)) {
       rpl = rb_Array(rpl);
-      rlen = RARRAY(rpl)->len;
+      rlen = RARRAY_LEN(rpl);
    } else {
       rpl = dvector_to_dvector(rpl);
       r = Get_Dvector(rpl);
@@ -925,7 +926,7 @@ static void dvector_splice(VALUE ary, long beg, long len, VALUE rpl) {
       dvector_mem_clear(d->ptr + d->len, beg - d->len);
       if (rlen > 0) {
          if (r != NULL) MEMCPY(d->ptr + beg, r->ptr, double, rlen);
-         else ary_to_dvector(RARRAY(rpl)->ptr, rlen, d->ptr);
+         else ary_to_dvector(RARRAY_PTR(rpl), rlen, d->ptr);
       }
       d->len = len;
    } else {
@@ -944,7 +945,7 @@ static void dvector_splice(VALUE ary, long beg, long len, VALUE rpl) {
       }
       if (rlen > 0) {
          if (r != NULL) MEMMOVE(d->ptr + beg, r->ptr, double, rlen);
-         else ary_to_dvector(RARRAY(rpl)->ptr, rlen, d->ptr + beg);
+         else ary_to_dvector(RARRAY_PTR(rpl), rlen, d->ptr + beg);
       }
    }
 }
@@ -1190,7 +1191,7 @@ PRIVATE
    Dvector *d2 = Get_Dvector(ary2);
    long i;
    if (d->len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for each2", d->len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for each2", d->len, d2->len);
    }
    for (i=0; i < d->len; i++) {
       rb_yield_values(2, rb_float_new(d->ptr[i]), rb_float_new(d2->ptr[i]));
@@ -1258,7 +1259,7 @@ PRIVATE
    Dvector *d2 = Get_Dvector(ary2);
    long i;
    if (d->len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for each2_with_index", d->len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for each2_with_index", d->len, d2->len);
    }
    for (i=0; i < d->len; i++) {
       rb_yield_values(3, rb_float_new(d->ptr[i]), rb_float_new(d2->ptr[i]), LONG2NUM(i));
@@ -1312,7 +1313,7 @@ PRIVATE
    Dvector *d2 = Get_Dvector(ary2);
    long len = d->len;
    if (len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for reverse_each2", len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for reverse_each2", len, d2->len);
    }
    while (len--) {
       rb_yield_values(2, rb_float_new(d->ptr[len]), rb_float_new(d2->ptr[len]));
@@ -1395,7 +1396,7 @@ PRIVATE
    Dvector *d2 = Get_Dvector(ary2);
    long len = d->len;
    if (len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for reverse_each2_with_index", 
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for reverse_each2_with_index", 
          len, d2->len);
    }
    while (len--) {
@@ -1522,7 +1523,7 @@ PRIVATE
         gam[j] = c[j-1] / bet;
         bet = b[j] - a[j]*gam[j];
         if (bet == 0.0) {
-            rb_raise(rb_eArgError, "zero divisor in tridag (j=%i)", j);
+            rb_raise(rb_eArgError, "zero divisor in tridag (j=%ld)", j);
         }
         u[j] = (r[j] - a[j]*u[j-1]) / bet;
     }
@@ -1632,7 +1633,7 @@ static VALUE dvector_sort_internal(VALUE ary) {
    else {
       ary2 = dvector_to_a(ary);
       ary2 = rb_ary_sort_bang(ary2);
-      ary_to_dvector(RARRAY(ary2)->ptr, d->len, d->ptr);
+      ary_to_dvector(RARRAY_PTR(ary2), d->len, d->ptr);
    }
    return ary;
 }
@@ -1727,7 +1728,7 @@ PRIVATE
          return dvector_new4_dbl(d->len, d->ptr);
       }
       ary = rb_Array(ary);
-      return dvector_new4(d->len, RARRAY(ary)->ptr);
+      return dvector_new4(d->len, RARRAY_PTR(ary));
    }
    collect = dvector_new2(0,d->len);
    for (i = 0; i < d->len; i++) {
@@ -1755,7 +1756,7 @@ PRIVATE
    Dvector *d = Get_Dvector(ary);
    Dvector *d2 = Get_Dvector(ary2);
    if (d->len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for collect2", d->len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for collect2", d->len, d2->len);
    }
    if (!rb_block_given_p()) {
       return dvector_collect(ary);
@@ -1813,7 +1814,7 @@ VALUE dvector_collect2_bang(VALUE ary, VALUE ary2) {
    Dvector *d = dvector_modify(ary);
    Dvector *d2 = Get_Dvector(ary2);
    if (d->len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for collect2!", d->len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for collect2!", d->len, d2->len);
    }
    for (i = 0; i < d->len; i++) {
       dvector_store(ary, i, rb_yield_values(2, rb_float_new(d->ptr[i]), rb_float_new(d2->ptr[i])));
@@ -2014,8 +2015,8 @@ VALUE dvector_prune_bang(VALUE ary, VALUE lst) {
    int i, lst_len, ary_len, pos, j;
    VALUE *lst_ptr;
    lst = rb_Array(lst);
-   lst_ptr = RARRAY(lst)->ptr;
-   lst_len = RARRAY(lst)->len;
+   lst_ptr = RARRAY_PTR(lst);
+   lst_len = RARRAY_LEN(lst);
    for (i = lst_len-1; i >= 0; i--) {
       ary_len = d->len;
       pos = NUM2INT(lst_ptr[i]);  // remove this one from ary
@@ -3011,7 +3012,7 @@ VALUE dvector_dot(VALUE ary1, VALUE ary2) {
    double *p1 = d1->ptr, *p2 = d2->ptr, sum = 0.0;
    long len = d1->len, i;
    if (len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for dot", d1->len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) for dot", d1->len, d2->len);
    }
    for (i=0; i<len; i++) sum += p1[i] * p2[i];
    return rb_float_new(sum);
@@ -4079,7 +4080,7 @@ VALUE dvector_apply_math_op2_bang(VALUE ary1, VALUE ary2, double (*op)(double, d
    double *p1 = d1->ptr, *p2 = d2->ptr;
    long len = d1->len, i;
    if (len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) math operation", d1->len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%ld vs %ld) math operation", d1->len, d2->len);
    }
    for (i=0; i<len; i++) p1[i] = (*op)(p1[i], p2[i]);
    return ary1;
@@ -4446,8 +4447,8 @@ VALUE Read_Dvectors(char *filename, VALUE destinations, int first_row_of_file, i
    if ((last_row_of_file != -1 && last_row_of_file < first_row_of_file) || filename == NULL) return false;
    if (destinations != Qnil) {
       cols_obj = rb_Array(destinations);
-      num_cols = RARRAY(cols_obj)->len;
-      cols_ptr = RARRAY(cols_obj)->ptr;
+      num_cols = RARRAY_LEN(cols_obj);
+      cols_ptr = RARRAY_PTR(cols_obj);
       for (i = 0; i < num_cols; i++) { /* first pass to check validity */
          col_obj = cols_ptr[i];
          if (col_obj == Qnil) continue;
@@ -4494,8 +4495,8 @@ VALUE Read_Dvectors(char *filename, VALUE destinations, int first_row_of_file, i
       }
       if (row == 0) {
          cols_obj = rb_Array(destinations);
-         num_cols = RARRAY(cols_obj)->len;
-         cols_ptr = RARRAY(cols_obj)->ptr;
+         num_cols = RARRAY_LEN(cols_obj);
+         cols_ptr = RARRAY_PTR(cols_obj);
       }
       buff_loc = 0;
       for (col = 0; col < num_cols; col++) {
@@ -4592,8 +4593,8 @@ VALUE Read_Rows_of_Dvectors(char *filename, VALUE destinations, int first_row_of
    char *buff, *num_str, *pend, c, *cptr;
    int num_rows = 0, i, row, col, buff_loc, skip = first_row_of_file - 1;
    rows_obj = rb_Array(destinations);
-   num_rows = RARRAY(rows_obj)->len;
-   rows_ptr = RARRAY(rows_obj)->ptr;
+   num_rows = RARRAY_LEN(rows_obj);
+   rows_ptr = RARRAY_PTR(rows_obj);
    for (i = 0; i < num_rows; i++) { /* first pass to check validity */
       row_obj = rows_ptr[i];
       if (row_obj == Qnil) continue;
@@ -4854,7 +4855,7 @@ double *Dvector_Data_Replace(VALUE dvector, long len, double *data) { /* copies
    return dvector_replace_dbls(dvector, len, data); }
 PRIVATE    
 VALUE Dvector_Create(void) { return dvector_new(); }
-
+/*
 PRIVATE int Find_First_Both_Greater(VALUE Xs, VALUE Ys, double x, double y) {
       int i;
       long xlen, ylen;
@@ -4882,7 +4883,7 @@ PRIVATE int Find_First_Both_Smaller(VALUE Xs, VALUE Ys, double x, double y) {
          }
       return -1;
       }
-
+*/
 PRIVATE    
 VALUE c_make_bezier_control_points_for_cubic_in_x(VALUE dest, double x0, double y0, double delta_x, double a, double b, double c)
 {
@@ -5011,7 +5012,6 @@ VALUE dvector_create_pm_cubic_interpolant(int argc, VALUE *argv, VALUE klass) {
    klass = Qnil;
    VALUE Xs = argv[0], Ys = argv[1];
    long xdlen, ydlen;
-   double start = 0.0, end = 0.0;
    double *X_data = Dvector_Data_for_Read(Xs, &xdlen);
    double *Y_data = Dvector_Data_for_Read(Ys, &ydlen);
    if (X_data == NULL || Y_data == NULL || xdlen != ydlen)
@@ -5060,7 +5060,7 @@ VALUE dvector_pm_cubic_interpolate(int argc, VALUE *argv, VALUE klass) {
    VALUE interpolant = argv[1];
    x = rb_Float(x);
    interpolant = rb_Array(interpolant);
-   if (RARRAY(interpolant)->len != 5)
+   if (RARRAY_LEN(interpolant) != 5)
       rb_raise(rb_eArgError, "interpolant must be array of length 5 from create_pm_cubic_interpolant");
    Dvector *Xs = Get_Dvector(rb_ary_entry(interpolant,0));
    Dvector *Ys = Get_Dvector(rb_ary_entry(interpolant,1));
@@ -5189,7 +5189,7 @@ VALUE dvector_spline_interpolate(int argc, VALUE *argv, VALUE klass) {
    VALUE interpolant = argv[1];
    x = rb_Float(x);
    interpolant = rb_Array(interpolant);
-   if (RARRAY(interpolant)->len != 5)
+   if (RARRAY_LEN(interpolant) != 5)
       rb_raise(rb_eArgError, "Spline interpolant must be array of length 5 from create_spline_interpolant");
    Dvector *Xs = Get_Dvector(rb_ary_entry(interpolant,0));
    Dvector *Ys = Get_Dvector(rb_ary_entry(interpolant,1));
@@ -5232,7 +5232,7 @@ VALUE dvector_linear_interpolate(int argc, VALUE *argv, VALUE klass) {
    Dvector *X_data = Get_Dvector(Xs);
    Dvector *Y_data = Get_Dvector(Ys);
    if (X_data->len <= 0 || X_data->len != Y_data->len)
-      rb_raise(rb_eArgError, "Xs and Ys for linear_interpolate must be equal length Dvectors: xlen %i ylen %i.", 
+      rb_raise(rb_eArgError, "Xs and Ys for linear_interpolate must be equal length Dvectors: xlen %ld ylen %ld.", 
          X_data->len, Y_data->len);
    x = rb_Float(x);
    double y = c_dvector_linear_interpolate(X_data->len, X_data->ptr, Y_data->ptr, NUM2DBL(x));
@@ -5255,8 +5255,8 @@ VALUE dvector_min_of_many(VALUE klass, VALUE ary) {
    double m=0.0, tmp;
    bool found_one = false;
    ary = rb_Array(ary);
-   ary_ptr = RARRAY(ary)->ptr;
-   ary_len = RARRAY(ary)->len;
+   ary_ptr = RARRAY_PTR(ary);
+   ary_len = RARRAY_LEN(ary);
    if (ary_len == 0) return Qnil;
    for (i = 0; i < ary_len; i++) {
       if (ary_ptr[i] == Qnil) continue;
@@ -5289,8 +5289,8 @@ VALUE dvector_max_of_many(VALUE klass, VALUE ary) {
    double m=0.0, tmp;
    bool found_one = false;
    ary = rb_Array(ary);
-   ary_ptr = RARRAY(ary)->ptr;
-   ary_len = RARRAY(ary)->len;
+   ary_ptr = RARRAY_PTR(ary);
+   ary_len = RARRAY_LEN(ary);
    if (ary_len == 0) return Qnil;
    for (i = 0; i < ary_len; i++) {
       if (ary_ptr[i] == Qnil) continue;
@@ -5496,14 +5496,17 @@ static VALUE dvector_convolve(VALUE self, VALUE kernel, VALUE middle)
     number of the line read
   * 'remove_space': whether to remove spaces at the beginning of a line. *This 
     option is currently not implemented !*
+  * 'comment_out': this should be an array into which the comments
+     will be dumped one by one.
   * 'default':  what to put when nothing was found but a number must be used
 
-  As a side note, the read time is highly non-linear, which suggests that
-  the read is memory-allocation/copying-limited, at least for big files.
+  In addition to these options that control the output, here are a few
+  others to tune memory allocation; these can strongly improve the
+  performance (or make it worse if you wish):
 
-  An internal memory allocation with aggressive policy should solve that,
-  that is, not using directly Dvectors (and it would be way faster to store
-  anyway).
+  * 'initial_size': the initial size of the memory buffers: if there
+    are not more lines than that, no additional memory allocation/copy
+    occurs.
 */
 static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
 {
@@ -5512,12 +5515,13 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
 				       rb_str_new2("default")));
   int remove_space = RTEST(rb_hash_aref(options, 
 					rb_str_new2("remove_space")));
-  int index_col = RTEST(rb_hash_aref(options, 
-				     rb_str_new2("index_col")));
+//  int index_col = RTEST(rb_hash_aref(options, 
+//				     rb_str_new2("index_col")));
   long skip_first = FIX2LONG(rb_hash_aref(options, 
 					  rb_str_new2("skip_first")));
   VALUE sep = rb_hash_aref(options, rb_str_new2("sep"));
   VALUE comments = rb_hash_aref(options, rb_str_new2("comments"));
+  VALUE comment_out = rb_hash_aref(options, rb_str_new2("comment_out"));
 
   /* Then, some various variables: */
   VALUE line;
@@ -5527,13 +5531,19 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
   long line_number = 0;
 
   /* 
-     Now come the fun part - rudimentary vectors management 
+     Now come the fun part - rudimentary vectors management
+
+     TODO: if the stream provides functionality to get its total size,
+     it could be interesting to estimate the total number of lines
+     based on some small heuristics
    */
   int nb_vectors = 0;		/* The number of vectors currently created */
   int current_size = 10;	/* The number of slots available */
   double ** vectors = ALLOC_N(double *, current_size);
   long index = 0;		/* The current index in the vectors */
-  int allocated_size = 5004;	/* The size available in the vectors */
+  /* The size available in the vectors */
+  int allocated_size = 
+    FIX2LONG(rb_hash_aref(options, rb_str_new2("initial_size"))); 
 
 
   int i;
@@ -5541,7 +5551,7 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
   /* The return value */
   VALUE ary;
 
-  /* We use a real gets so we can also rely on StringIO, for instance */
+  /* We use a real gets so we can also use StringIO, for instance */
   while(RTEST(line = rb_funcall(stream, gets_id, 0))) {
     VALUE pre, post, match;
     const char * line_ptr;
@@ -5564,8 +5574,11 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
       line = rb_str_new2(line_ptr);
 
     /* ... or a comment line */
-    if(RTEST(comments) && RTEST(rb_reg_match(comments, line))) 
+    if(RTEST(comments) && RTEST(rb_reg_match(comments, line))) {
+      if(RTEST(comment_out))
+	rb_ary_push(comment_out, line);
       continue;
+    }
 
     /* Then, we remove the newline: */
     post = line;
@@ -5630,6 +5643,288 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
   return ary;
 }
 
+/*
+  Returns a list of local extrema of the vector, organized thus:
+  
+   [ [:min, idmin1], [:max, idmax1], ...]
+  
+  The values are pushed in the order in which they are found. It works
+  thus: it scans the vector and looks around the current point in a
+  given window. If the current point is the maximum or the minimum, it
+  is considered as a local maximum/minimum. Control over which extrema
+  are included is given to the used through threshold mechanisms.
+
+  The _options_ hash controls how the peaks are detected:
+  * _window_: the number of elements on which we look on
+    both sides (default 5, ie the local maximum is over 11 points)
+  * _threshold_: the minimum amplitude the extrema must have to
+    be considered (default 0)
+  * _dthreshold_: how much over/under the average an extremum must be
+    (default 0) 
+  * _or_: whether the _threshold_ and _dthreshold_ tests are both
+    necessary or if only one is (default false: both tests are
+    necessary)
+
+    *Note:* beware of NANs ! They *will* screw up peak detection, as
+  they are neither bigger nor smaller than anything...  
+*/
+static VALUE dvector_extrema(int argc, VALUE *argv, VALUE self)
+{
+  long window = 5;
+  double threshold = 0;
+  double dthreshold = 0;
+  int inclusive = 1;
+  
+  if(argc == 1) {
+    VALUE t;
+    t = rb_hash_aref(argv[0], rb_str_new2("window"));
+    if(RTEST(t)) {
+      window = FIX2LONG(t);
+    }
+    t = rb_hash_aref(argv[0], rb_str_new2("threshold"));
+    if(RTEST(t)) {
+      threshold = rb_num2dbl(t);
+    }
+    t = rb_hash_aref(argv[0], rb_str_new2("dthreshold"));
+    if(RTEST(t)) {
+      dthreshold = rb_num2dbl(t);
+    }
+    
+    t = rb_hash_aref(argv[0], rb_str_new2("or"));
+    inclusive = ! RTEST(t);
+  } else if(argc > 1)
+    rb_raise(rb_eArgError, "Dvector.extrema only takes 0 or 1 argument");
+
+  /* Handling of the vector */
+  long len, i,j;
+  double * data = Dvector_Data_for_Read(self, &len);
+  VALUE s_min = ID2SYM(rb_intern("min"));
+  VALUE s_max = ID2SYM(rb_intern("max"));
+
+  
+
+  VALUE ret = rb_ary_new();
+		       
+  for(i = 0; i < len; i++) {
+
+    /* This is stupid and will need decent optimization when I have
+       time */
+    long first = i > window ? i - window : 0;
+    double cur_min = data[first];
+    long cur_min_idx = first;
+    double cur_max = data[first];
+    long cur_max_idx = first;
+    double average = 0;
+    long nb = 0;
+    
+    for(j = first; (j < i+window) && (j < len); j++,nb++) {
+      average += data[j];
+      if(data[j] <= cur_min) {
+	cur_min = data[j];
+	cur_min_idx = j;
+      }
+      if(data[j] >= cur_max) {
+	cur_max = data[j];
+	cur_max_idx = j;
+      }
+    }
+    average /= nb;
+
+    if(cur_min_idx == i) {
+      /* This is a potential minimum */
+      if((inclusive && 
+	  (fabs(cur_min) >= threshold) && 
+	  (fabs(cur_min - average) >= dthreshold))
+	 || (!inclusive && 
+	     ((fabs(cur_min) >= threshold) ||
+	      (fabs(cur_min - average) >= dthreshold))
+	     )) {
+	VALUE min = rb_ary_new();
+	rb_ary_push(min, s_min);
+	rb_ary_push(min, LONG2FIX(i));
+	rb_ary_push(ret, min);
+      }
+    }
+    else if(cur_max_idx == i) {
+      /* A potential maximum */
+      if((inclusive && 
+	  (fabs(cur_max) >= threshold) && 
+	  (fabs(cur_max - average) >= dthreshold))
+	 || (!inclusive && 
+	     ((fabs(cur_max) >= threshold) ||
+	      (fabs(cur_max - average) >= dthreshold))
+	     )) {
+	VALUE max = rb_ary_new();
+	rb_ary_push(max, s_max);
+	rb_ary_push(max, LONG2FIX(i));
+	rb_ary_push(ret, max);
+      }
+    }
+  }
+  return ret;
+}
+
+/* This is the FFTW-based part of the game */
+#ifdef HAVE_FFTW3_H
+#include <fftw3.h>
+
+/* 
+   Performs an in-place Fourier transform of the vector. The results
+   is stored in the so-called "half-complex" format (see
+   http://www.fftw.org/fftw3_doc/The-Halfcomplex_002dformat-DFT.html
+   for more information).
+
+*/
+static VALUE dvector_fft(VALUE self)
+{
+  long len;
+  double * values = Dvector_Data_for_Write(self, &len);
+  fftw_plan plan = fftw_plan_r2r_1d(len, values, values,
+				    FFTW_R2HC, FFTW_ESTIMATE);
+  fftw_execute(plan);
+  fftw_destroy_plan(plan);
+  return self;
+}
+
+/* 
+   Performs a reverse in-place Fourier transform of the vector. The
+   original data must have been stored in the so called "half-complex"
+   format (see #fft!).
+*/
+
+static VALUE dvector_rfft(VALUE self)
+{
+  long len;
+  double * values = Dvector_Data_for_Write(self, &len);
+  fftw_plan plan = fftw_plan_r2r_1d(len, values, values,
+				    FFTW_HC2R, FFTW_ESTIMATE);
+  fftw_execute(plan);
+  fftw_destroy_plan(plan);
+  return self;
+}
+
+/* 
+   Now, small functions to manipulate the FFTed data:
+   * multiply them
+   * divide them
+   * get (the square of) their module
+*/
+
+
+/* 
+   Returns the power spectra of the ffted data (ie the square of the
+   norm of the complex fourier coefficients.
+   
+   The returned value is a new Dvector of size about two times smaller
+   than the original (precisely size/2 + 1)
+
+   For some reasons, convolutions don't work for now.
+*/
+static VALUE dvector_fft_spectrum(VALUE self)
+{
+  long len;
+  const double * values = Dvector_Data_for_Read(self, &len);
+  /* First compute the size of the target: */
+  long target_size = len/2+1;
+  long i;
+  VALUE retval = dvector_new2(target_size,target_size);
+  double * ret = Dvector_Data_for_Write(retval,NULL);
+
+  /* Pointer to real and imaginary parts */
+  const double * real;
+  const double * img;
+  ret[0] = values[0] * values[0];
+
+
+  /* The Nyquist frequency */
+  if(len % 2 == 0)
+    ret[target_size - 1] = values[target_size-1] * values[target_size-1];
+  for(i = 1, real = values + 1, img = values + len-1; i < len/2;
+      i++, real++, img--)
+    ret[i] = *real * *real + *img * *img;
+  return retval;
+}
+
+/*
+  Converts the FFTed data in the complex conjugate
+*/
+static VALUE dvector_fft_conj(VALUE self)
+{
+  long len;
+  double * v1 = Dvector_Data_for_Write(self, &len);
+  double * img;
+  long i;
+  for(i = 1, img = v1 + len-1; i < (len+1)/2;
+      i++, img--)
+    *img = -*img;
+  return self;
+}
+
+
+/* 
+   Multiplies the FFTed data held in the vector by another vector. The
+   behaviour depends on the size of the target vector:
+   
+   * if it is the same size, it is assumed to be FFTed data
+   * if it is the same size of a power spectrum, then it is assumed that it
+     is multiplication by real values
+   * anything else won't make this function happy.
+
+   As a side note, if you only want multiplication by a scalar, the
+   standard #mul! should be what you look for.
+ */
+static VALUE dvector_fft_mul(VALUE self, VALUE m)
+{
+  long len;
+  double * v1 = Dvector_Data_for_Write(self, &len);
+  long len2;
+  const double * v2 = Dvector_Data_for_Write(m, &len2);
+  if(len2 == len) {		/* Full complex multiplication */
+    const double * m_img;
+    const double * m_real;
+    double * v_img;
+    double * v_real;
+    long i;
+    /* First, special cases */
+    v1[0] *= v2[0];
+    if(len % 2 == 0)
+      v1[len/2] *= v2[len/2];
+    
+    for(i = 1, m_real = v2 + 1, m_img = v2 + len-1,
+	  v_real = v1 + 1, v_img = v1 + len-1; i < (len+1)/2;
+	i++, m_real++, v_real++, m_img--, v_img--) {
+      double r = *m_real * *v_real - *m_img * *v_img;
+      *v_img = *m_real * *v_img + *v_real * *m_img;
+      *v_real = r;
+    }
+    return self;
+  }
+  else if(len2 == len/2+1) {		/* Complex * real*/
+    const double * val;
+    double * v_img;
+    double * v_real;
+    long i;
+    /* First, special cases */
+    v1[0] *= v2[0];
+    if(len % 2 == 0)
+      v1[len/2] *= v2[len/2];
+    
+    for(i = 1, val = v2 + 1,
+	  v_real = v1 + 1, v_img = v1 + len-1; i < (len+1)/2;
+	i++, val++, v_real++, v_img--) {
+      *v_real *= *val;
+      *v_img *= *val;
+    }
+    return self;
+  }
+  else {
+    rb_raise(rb_eArgError, "incorrect Dvector size for fft_mul!");
+  }
+}
+
+
+#endif
+
 
 /* 
  * Document-class: Dobjects::Dvector
@@ -5958,6 +6253,21 @@ void Init_Dvector() {
 			      dvector_fast_fancy_read, 2);
 
 
+   /* Local extrema */
+   rb_define_method(cDvector, "extrema", dvector_extrema, -1);
+
+   /* FFT functions */
+#ifdef HAVE_FFTW3_H
+
+   rb_define_method(cDvector, "fft!", dvector_fft, 0);
+   rb_define_method(cDvector, "rfft!", dvector_rfft, 0);
+   rb_define_method(cDvector, "fft_spectrum", dvector_fft_spectrum, 0);
+   rb_define_method(cDvector, "fft_mul!", dvector_fft_mul, 1);
+   rb_define_method(cDvector, "fft_conj!", dvector_fft_conj, 0);
+
+#endif
+
+
    dvector_output_fs = Qnil;
    rb_global_variable(&dvector_output_fs);
    dvector_output_fs = rb_str_new2(" ");