tioga 1.4

data/split/Dvector/dvector_intern.h

@@ -0,0 +1,142 @@
+/* Dvector.h */
+/*
+   Copyright (C) 2005  Bill Paxton
+
+   Dvector is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Dvector is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with Dvector; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __Dvector_H__
+#define __Dvector_H__
+
+#include "ruby.h"
+#include <stdbool.h>
+#include <namespace.h>
+
+
+
+/*======================================================================*/
+
+PUBLIC void Init_Dvector();
+/* dirty hack to prevent namespace conflicts */
+PRIVATE bool Is_Dvector(VALUE obj);
+PRIVATE double *Dvector_Data_for_Read(VALUE dvector, long *len_ptr); /* returns pointer to the dvector's data (which may be shared) */
+PRIVATE double *Dvector_Data_Copy(VALUE dvector, long *len_ptr); /* like Dvector_Data_for_Read, but returns pointer to a copy of the data */
+PRIVATE double *Dvector_Data_for_Write(VALUE dvector, long *len_ptr);
+PRIVATE double *Dvector_Data_Resize(VALUE dvector, long new_len);
+PRIVATE double *Dvector_Data_Replace(VALUE dvector, long len, double *data); /* copies the data into the dvector */
+PRIVATE VALUE Dvector_Create(void);
+PRIVATE void Dvector_Push_Double(VALUE ary, double val);
+PRIVATE void Dvector_Store_Double(VALUE ary, long idx, double val);
+
+PRIVATE VALUE Read_Dvectors(char *filename, VALUE destinations, int first_row_of_file, int number_of_rows);
+PRIVATE VALUE Read_Row(char *filename, int row, VALUE row_ary);
+
+/* implementations for Ruby methods */
+
+PRIVATE VALUE dvector_apply_math_op(VALUE source, double (*op)(double));
+PRIVATE VALUE dvector_apply_math_op2(VALUE ary1, VALUE ary2, double (*op)(double, double));
+PRIVATE VALUE dvector_apply_math_op_bang(VALUE ary, double (*op)(double));
+PRIVATE VALUE dvector_apply_math_op2_bang(VALUE ary1, VALUE ary2, double (*op)(double, double));
+
+PRIVATE VALUE dvector_freeze(VALUE ary);
+PRIVATE VALUE dvector_frozen_p(VALUE ary);
+PRIVATE VALUE make_new_dvector(VALUE klass, long len, long capa);
+PRIVATE VALUE dvector_new2(long len, long capa);
+PRIVATE VALUE dvector_new();
+PRIVATE VALUE dvector_new4(long len, VALUE *data);
+PRIVATE VALUE dvector_new4_dbl(long len, double *data);
+PRIVATE VALUE dvector_check_array_type(VALUE ary);
+PRIVATE VALUE dvector_initialize(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_push(VALUE ary, VALUE item);
+PRIVATE VALUE dvector_push_m(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_pop(VALUE ary);
+PRIVATE VALUE dvector_shift(VALUE ary);
+PRIVATE VALUE dvector_unshift_m(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_entry(VALUE ary, long offset);
+PRIVATE VALUE dvector_subseq(VALUE ary, long beg, long len);
+PRIVATE VALUE dvector_aref(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_at(VALUE ary, VALUE pos);
+PRIVATE VALUE dvector_first(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_last(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_uniq_bang(VALUE ary);
+PRIVATE VALUE dvector_uniq(VALUE ary);
+PRIVATE VALUE dvector_fetch(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_index(VALUE ary, VALUE val);
+PRIVATE VALUE dvector_rindex(VALUE ary, VALUE val);
+PRIVATE VALUE dvector_aset(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_insert(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_each(VALUE ary);
+PRIVATE VALUE dvector_each2(VALUE ary, VALUE ary2);
+PRIVATE VALUE dvector_each_index(VALUE ary);
+PRIVATE VALUE dvector_each_with_index(VALUE ary);
+PRIVATE VALUE dvector_each2_with_index(VALUE ary, VALUE ary2);
+PRIVATE VALUE dvector_reverse_each(VALUE ary);
+PRIVATE VALUE dvector_reverse_each2(VALUE ary, VALUE ary2);
+PRIVATE VALUE dvector_reverse_each_index(VALUE ary);
+PRIVATE VALUE dvector_reverse_each_with_index(VALUE ary);
+PRIVATE VALUE dvector_reverse_each2_with_index(VALUE ary, VALUE ary2);
+PRIVATE VALUE dvector_length(VALUE ary);
+PRIVATE VALUE dvector_empty_p(VALUE ary);
+PRIVATE VALUE dvector_dup(VALUE ary);
+PRIVATE VALUE dvector_join(VALUE ary, VALUE sep);
+PRIVATE VALUE dvector_join_m(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_to_s(VALUE ary);
+PRIVATE VALUE dvector_to_a(VALUE ary);
+PRIVATE VALUE dvector_read(int argc, VALUE *argv, VALUE klass);
+PRIVATE VALUE dvector_read_row(int argc, VALUE *argv, VALUE klass);
+PRIVATE VALUE dvector_read_rows(int argc, VALUE *argv, VALUE klass);
+PRIVATE VALUE dvector_reverse(VALUE ary);
+PRIVATE VALUE dvector_reverse_bang(VALUE ary);
+PRIVATE VALUE dvector_reverse_m(VALUE ary);
+PRIVATE VALUE dvector_sort_bang(VALUE ary);
+PRIVATE VALUE dvector_sort(VALUE ary);
+PRIVATE VALUE dvector_collect(VALUE ary);
+PRIVATE VALUE dvector_collect2(VALUE ary, VALUE ary2);
+PRIVATE VALUE dvector_collect_bang(VALUE ary);
+PRIVATE VALUE dvector_collect2_bang(VALUE ary, VALUE ary2);
+PRIVATE VALUE dvector_values_at(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_select(VALUE ary);
+PRIVATE VALUE dvector_delete(VALUE ary, VALUE item);
+PRIVATE VALUE dvector_delete_at(VALUE ary, long pos);
+PRIVATE VALUE dvector_slice_bang(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_reject_bang(VALUE ary);
+PRIVATE VALUE dvector_reject(VALUE ary);
+PRIVATE VALUE dvector_delete_if(VALUE ary);
+PRIVATE VALUE dvector_replace(VALUE dest, VALUE orig);
+PRIVATE VALUE dvector_clear(VALUE ary);
+PRIVATE VALUE dvector_fill(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_eql(VALUE ary1, VALUE ary2);
+PRIVATE VALUE dvector_includes(VALUE ary, VALUE item);
+PRIVATE VALUE dvector_cmp(VALUE ary1, VALUE ary2);
+PRIVATE VALUE dvector_mod(VALUE ary, VALUE arg);
+PRIVATE VALUE dvector_min(int argc, VALUE *argv, VALUE ary);
+PRIVATE VALUE dvector_max(int argc, VALUE *argv, VALUE ary);
+
+PRIVATE void c_dvector_create_spline_interpolant(int n_pts_data, double *Xs, double *Ys,
+    bool start_clamped, double start_slope, bool end_clamped, double end_slope,
+    double *Bs, double *Cs, double *Ds);
+PRIVATE VALUE dvector_create_spline_interpolant(int argc, VALUE *argv, VALUE klass);
+    
+PRIVATE double c_dvector_spline_interpolate(double x, int n_pts_data, 
+    double *Xs, double *Ys, double *Bs, double *Cs, double *Ds);
+PRIVATE VALUE dvector_spline_interpolate(int argc, VALUE *argv, VALUE klass);
+
+PRIVATE double c_dvector_linear_interpolate(int num_pts, double *xs, double *ys, double x);
+PRIVATE VALUE dvector_linear_interpolate(int argc, VALUE *argv, VALUE klass);
+
+/* end of dirty hack */
+
+#endif   /* __Dvector_H__ */
+

data/split/Dvector/extconf.rb

@@ -0,0 +1,4 @@
+# Dtable installation file
+require 'mkmf'
+
+create_makefile 'Dobjects/Dvector'

data/split/Dvector/include/dvector.h

@@ -0,0 +1,61 @@
+/* Dvector.h */
+/*
+   Copyright (C) 2005  Bill Paxton
+
+   Dvector is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Dvector is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with Dvector; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __Dvector_H__
+#define __Dvector_H__
+
+/* this file has been heavily modified by Vincent Fourmond to take care
+   of the 'RCR330' scheme of exporting symbols 
+*/
+
+#include <symbols.h>
+#include <stdbool.h>
+
+/*======================================================================*/
+
+/* functions for handling Dvectors: */
+
+DECLARE_SYMBOL(double *, Dvector_Data_for_Read, (VALUE dvector, long *len_ptr));
+ /* returns pointer to the dvector's data (which may be shared) */
+DECLARE_SYMBOL(double *, Dvector_Data_Copy, (VALUE dvector, long *len_ptr)); 
+/* like Dvector_Data_for_Read, but returns pointer to a copy of the data */
+DECLARE_SYMBOL(double *, Dvector_Data_for_Write, 
+		(VALUE dvector, long *len_ptr));
+DECLARE_SYMBOL(double *, Dvector_Data_Resize, (VALUE dvector, long new_len));
+DECLARE_SYMBOL(double *, Dvector_Data_Replace,
+	       (VALUE dvector, long len, double *data)); 
+/* copies the data into the dvector */
+DECLARE_SYMBOL(VALUE, Dvector_Create, (void));
+DECLARE_SYMBOL(void, Dvector_Store_Double, (VALUE ary, long idx, double val));
+/* pushes one element onto the vector */
+DECLARE_SYMBOL(void, Dvector_Push_Double, (VALUE ary, double val));
+
+/* functions for interpolation */
+DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
+	       (int num_pts, double *xs, double *ys, double x));
+DECLARE_SYMBOL(void, c_dvector_create_spline_interpolant,
+	       (int n_pts_data, double *Xs, double *Ys,
+		bool start_clamped, double start_slope, 
+		bool end_clamped, double end_slope,
+		double *As, double *Bs, double *Cs));
+#endif   /* __Dvector_H__ */
+

data/split/Dvector/lib/Dvector_extras.rb

@@ -0,0 +1,328 @@
+#  Tioga::Dvector_extras.rb
+
+module Dobjects 
+
+  # MathEvaluator enables one to evaluate a simple mathematical expression
+  # such as "x[0] + cos(x[1])", where the array x is given at each call to
+  # compute, or "x + y**z", or...
+  # 
+  # This class acts as a backend for Dvector.compute_formula, to make sure
+  # that the Math module is included, without the drawback of cluttering
+  # all Math functions in Dvector, which would admittedly be quite stupid.
+
+  class MathEvaluator
+    include Math
+
+    # Creates an evaluator for a formula. +formula+ is the formula. It is
+    # transformed into a block that takes +argname+ as an argument --
+    # +argname+ can be whatever you want. +mods+ are the modules you would
+    # like the formula to include. Math is included by default, but you
+    # can include other ones to make other kinds of functions available.
+    #
+    #  MathEvaluator.new("col[0] + col[1]", "col")
+    #  MathEvaluator.new("x*cos(y)", "x,y")
+    def initialize(formula, argname, mods = [])
+      for mod in mods
+        self.extend mod
+      end
+      @block = eval "proc { |#{argname}| #{formula} }"
+    end
+
+    # This function does the actual evaluation with the blocks
+    # given.
+    #
+    #  e = MathEvaluator.new("x*y", "x,y")
+    #  e.compute(1,2)         -> 2
+    def compute(*args)
+      return @block.call(*args)
+    end
+  end
+
+  class Dvector
+      
+    def to_dvector
+      self
+    end
+
+    # Dvector.fancy_read's defaults options. See that function for
+    # more details
+    FANCY_READ_DEFAULTS = { 
+      'sep' => /\s+/,
+      'comments' => /^\s*\#/,
+      'skip_first' => 0,
+      'index_col' => false,
+      'headers' => nil, # not used for now.
+      'default' => 0.0/0.0, # defaults to NaN
+      'remove_space' => true ,# removes spaces at the beginning of the lines
+    }
+
+
+    # This function reads in +stream+ (can an IO object or a String,
+    # in which case it represents the name of a file to be opened)
+    # the columns specified by +cols+ and returns them. column 0 is the
+    # first column. If +cols+ is +nil+, then fancy_read attempts to find
+    # all the columns in the file, while filling absent data with NaN.
+    #
+    # +opts+ is a hash for tuning the behavior of the reading. It can hold
+    # the following keys:
+    # 'sep':: the record separator
+    # 'comments':: a regular expression matching comment lines
+    # 'skip_first':: how many lines to skip at the beginning of the file,
+    # 'default':: the value taken for missing elements
+    # 'index_col':: if set to true, the first column contains the
+    #               indices of the corresponding lines (0 for first and so on)
+
+    def Dvector.fancy_read(stream, cols = nil, opts = {}) # :doc:
+      # first, we turn the stream into a real IO stream
+      if stream.is_a?(String)
+        stream = File.open(stream)
+      end
+      raise ArgumentError.new("'stream' should have a gets method") unless 
+        stream.respond_to? :gets
+      
+      # we take default options and override them with opts
+      o = FANCY_READ_DEFAULTS.merge(opts)
+      
+      # strip off the first lines.
+      while o["skip_first"] > 0
+        stream.gets
+        o["skip_first"] -= 1
+      end
+
+      # then, parsing the lines. We store the results in an array. We read up
+      # all columns, regardless of what is asked (it doesn't slow that much
+      # the process -- or does it ?)
+      
+      columns = []
+      line_number = 0 # the number of the significant lines read so far
+      
+      while line = stream.gets
+        next if line =~ o["comments"]
+        next if line =~ /^\s*$/ # skip empty lines
+        if o["remove_space"]
+          line.gsub!(/^\s+/,'')
+        end
+  
+        elements = line.split(o["sep"])
+        # now, the fun: the actual reading.
+        # we first turn this elements into floats:
+        numbers = elements.collect do |s| 
+          begin 
+            a = Float(s)
+          rescue
+            o["default"]
+          end
+        end
+
+        if numbers.size < columns.size 
+          # we pad it with default values
+          while numbers.size < columns.size
+            numbers << o["default"]
+          end
+        else
+          # in that case, we need to create new Dvectors to match the
+          # size of numbers
+          while columns.size < numbers.size
+            columns << Dvector.new(line_number, o["default"]) 
+          end
+        end
+        # now, we should have the same number of elements both
+        # in numbers and in columns
+        columns.size.times do |i|
+          columns[i] << numbers[i]
+        end
+        # and it's done ;-) !
+
+        line_number += 1
+      end
+      # Adding the index columns if necessary
+      if o["index_col"] 
+        columns.unshift(Dvector.new(columns[0].length) { |i| i})
+      end
+
+      return columns unless cols
+      return cols.collect { |i| 
+        columns[i]
+      }
+    end
+
+    # This function is a rudimentary formula computing stuff. Give it
+    # a text _formula_ and an array of Dvectors (_a_), and it returns a
+    # Dvector with the result. The formula should contain the following;
+    # column[n]:: represents the current element of the n th
+    #             Dvector of the array
+    #
+    # This is just a try, and should be implemented in C rather than in
+    # Ruby. But if you're looking for simplicity, here you go ;-) !
+    #
+    # _modules_ are the modules you would wish the evaluator to +include+. 
+    # This feature enables one to make sure custom functions are included
+
+    def Dvector.compute_formula(formula, a, modules = []) # :doc:
+
+      evaluator = MathEvaluator.new(formula, "column", modules)
+      # if we reach this place, it means that there a no big syntax errors ;-)
+      
+      # we now need to inspect the array given, and make sure that there is
+      # and transform it into a clean stuff (an array with only Dvectors and
+      # nil elements).
+      
+      target = []
+      last = nil
+      a.each { |elem| 
+        if elem.is_a? Dvector
+          target << elem
+          last = elem
+        else
+          target << nil
+        end
+      }
+      
+      raise "No Dvector found" unless last
+      
+      # we check all the vectors have the same length
+      target.each {|x| 
+        if x && x.length != last.length
+          raise "Dvectors should have all the same length !" 
+        end
+      }
+      
+      res = Dvector.new
+      
+      last.each_index { |i|
+        args = target.collect { |val| 
+          if val
+            val[i]
+          else 
+            nil
+          end
+        }
+        # we add the index at the beginning:
+        #         args.unshift(i) 
+        # Commented out for simplicity
+        
+        # then we call the block:
+        elem = evaluator.compute(args)
+        res << elem
+      }
+      
+      return res
+    end
+
+    WRITE_DEFAULTS = {
+      'sep' => "\t",
+      'write_mode' => "a",
+    }
+
+    # Writes an array of Dvectors into a text _file_ 
+    def Dvector.write(file, cols, options = {})
+      ops = WRITE_DEFAULTS.update(options)
+      if file.is_a?(String)
+        file = File.open(file, ops["write_mode"])
+      end 
+      nb = cols.map {|d| d.size}.max # The number of lines
+      nb.times do |i|
+        file.puts(cols.map {|d| d[i].to_s }.join(ops["sep"]))
+      end
+    end
+    
+  end
+end
+
+# Modified by Vincent Fourmond to have a nice Dvector module
+# instead of the Tioga module.
+# add arithmetic operators for Float and Fixnum with Dvec
+
+class Array # :nodoc: all
+    def to_dvector
+        Dobjects::Dvector[*self]
+    end
+end
+
+class Float # :nodoc: all
+    alias :pre_dvec_add :+
+    def +(a)
+        if a.class == Dobjects::Dvector
+            a+self
+        else
+            pre_dvec_add(a)
+        end
+    end
+    alias :pre_dvec_sub :-
+    def -(a)
+        if a.class == Dobjects::Dvector
+            a.neg+self
+        else
+            pre_dvec_sub(a)
+        end
+    end
+    alias :pre_dvec_mult :*
+    def *(a)
+        if a.class == Dobjects::Dvector
+            a*self
+        else
+            pre_dvec_mult(a)
+        end
+    end
+    alias :pre_dvec_div :/
+    def /(a)
+        if a.class == Dobjects::Dvector
+            a.inv*self
+        else
+            pre_dvec_div(a)
+        end
+    end
+    alias :pre_dvec_pow :**
+    def **(a)
+        if a.class == Dobjects::Dvector
+            a.as_exponent_of(self)
+        else
+            pre_dvec_pow(a)
+        end
+    end
+    
+end
+
+class Fixnum # :nodoc: all
+    alias :pre_dvec_add :+
+    def +(a)
+        if a.class == Dobjects::Dvector
+            a+self
+        else
+            pre_dvec_add(a)
+        end
+    end
+    alias :pre_dvec_sub :-
+    def -(a)
+        if a.class == Dobjects::Dvector
+            a.neg+self
+        else
+            pre_dvec_sub(a)
+        end
+    end
+    alias :pre_dvec_mult :*
+    def *(a)
+        if a.class == Dobjects::Dvector
+            a*self
+        else
+            pre_dvec_mult(a)
+        end
+    end
+    alias :pre_dvec_div :/
+    def /(a)
+        if a.class == Dobjects::Dvector
+            a.inv*self
+        else
+            pre_dvec_div(a)
+        end
+    end
+    alias :pre_dvec_pow :**
+    def **(a)
+        if a.class == Dobjects::Dvector
+            a.as_exponent_of(self)
+        else
+            pre_dvec_pow(a)
+        end
+    end
+end
+