ctioga2 0.0 → 0.1

data/lib/ctioga2/data/backends/description.rb

@@ -22,7 +22,7 @@ require 'ctioga2/commands/groups'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 59 $', '$Date: 2009-05-28 23:15:50 +0200 (Thu, 28 May 2009) $')
+  Version::register_svn_info('$Revision: 155 $', '$Date: 2010-06-21 21:41:32 +0200 (Mon, 21 Jun 2010) $')
   
 
   module Data
@@ -73,10 +73,10 @@ module CTioga2
       # create objects at run-time, the classes used by describe
       # *should not need any parameter for #initialize*.
       #
-      # TODO: add functions to prepare commands to set the various
+      # \todo add functions to prepare commands to set the various
       # parameters
       #
-      # TODO: write the parameters stuff again...
+      # \todo write the parameters stuff again...
       class BackendDescription
         # The Class to instantiate. 
         attr_accessor :object_class
@@ -149,16 +149,16 @@ module CTioga2
         # In addition, this function creates a group to store Backend
         # commands.
         #
-        # TODO: finish this !!!
+        # \todo finish this !!!
         def create_backend_commands
           group = CmdGroup.
             new("backend-#{@name}", 
                 "The '#{@name}' backend: #{@long_name}",
                 "The commands in this group drive the "+
-                "behaviour of the #{@long_name} backend.\n" + 
-                @description,
+                "behaviour of the {backend: #{@name}} backend;\n" + 
+                "see its documentation for more information",
                 DefaultBackendGroupPriority)
-
+          
           backend_options = {}
 
           # Again, each is needed for scoping problems.
@@ -175,9 +175,8 @@ module CTioga2
             backend_options[param.name] = arg.dup
           end
 
-          # TODO: add option parsing
           Cmd.new("#{@name}", nil, "--#{@name}", [], 
-                  backend_options, "Selects the '#{@name}' backend", 
+                  backend_options, "Selects the '{backend: #{@name}}' backend", 
                   nil, group) do |plotmaker, options|
             plotmaker.data_stack.backend_factory.set_current_backend(@name)
             for k,v in options
@@ -390,11 +389,11 @@ module CTioga2
               if parents_params.key?(n)
                 description.add_param(parents_params[n])
               else
-                warn "Param #{n} not found"
+                warn { "Param #{n} not found" }
               end
             end
           else
-            warn "The parent class has no description"
+            warn { "The parent class has no description" }
           end
         end
         

data/lib/ctioga2/data/datacolumn.rb

@@ -1,5 +1,5 @@
 # datacolumn.rb: a class holding a 'column' of data
-# copyright (c) 2009 by Vincent Fourmond
+# copyright (c) 2009-2011 by Vincent Fourmond
   
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,15 +17,15 @@ require 'ctioga2/utils'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 81 $', '$Date: 2009-06-11 21:14:59 +0200 (Thu, 11 Jun 2009) $')
+  Version::register_svn_info('$Revision: 229 $', '$Date: 2011-01-17 17:34:57 +0100 (Mon, 17 Jan 2011) $')
 
   module Data
 
     # This class holds one column, possibly with error bars.
     #
-    # TODO: a way to concatenate two DataColumns
+    # \todo a way to concatenate two DataColumns
     #
-    # TODO: a way to easily access the by "lines"
+    # \todo a way to easily access the by "lines"
     class DataColumn
       
       # A Dvector holding ``real'' values
@@ -37,11 +37,11 @@ module CTioga2
       # A Dvector holding maximal values
       attr_accessor :max_values
 
-      # TODO: a method that resembles the code in the old text backend
+      # \todo a method that resembles the code in the old text backend
       # to set errors according to a speficication (relative,
       # absolute, already max/min)
 
-      # TODO: a dup !
+      # \todo a dup !
 
       def initialize(values, min = nil, max = nil)
         @values = values
@@ -49,6 +49,19 @@ module CTioga2
         @max_values = max
       end
 
+      # Creates a DataColumn object
+      def self.create(number, with_errors = false)
+        a = Dobjects::Dvector.new(number, NaN::NaN)
+        if with_errors
+          b = Dobjects::Dvector.new(number, NaN::NaN)
+          c = Dobjects::Dvector.new(number, NaN::NaN)
+        else
+          b = nil
+          c = nil
+        end
+        return self.new(a, b, c)
+      end
+
 
       # Yields all the vectors in turn to apply a given
       # transformation.
@@ -90,26 +103,59 @@ module CTioga2
         end
       end
 
-      # Values, [value, min, max], at the given index. If #min and
-      # #max are nil only [value] is returned -- unless _expand_ is
-      # set, in which case we make up a default value for min and max.
-      def values_at(i, expand = false)
+      # Values at the given index.
+      #
+      # If _with_errors_ is false, only [value] is returned.
+      #
+      # If _with_errors_ is true, then, non-existent values are
+      # expanded to _nil_ if _expand_nil_ is true or to value if not.
+      def values_at(i, with_errors = false, expand_nil = true)
+        if ! with_errors 
+          return [@values[i]]
+        end
         if has_errors?
           return [@values[i], @min_values[i], @max_values[i]]
         else
-          if expand
-            return [@values[i], @values[i], @values[i]]
+          if expand_nil
+            return [@values[i], nil, nil]
           else
-            return [@values[i]]
+            return [@values[i], @values[i], @values[i]]
           end
         end
       end
 
+      # Vectors: all values if there are error bars, or only the
+      # #value one if there isn't.
+      def vectors
+        if has_errors?
+          return [@values, @min_values, @max_values]
+        else
+          return [@values]
+        end
+      end
+
       # Returns the number of elements.
       def size
         return @values.size
       end
 
+      # Sets the values at the given index
+      def set_values_at(i, value, min = nil, max = nil)
+        @values[i] = value
+        if min && max
+          ensure_has_errors
+          @min_values[i] = min
+          @max_vaklues[i] = max
+        end
+      end
+
+      # Appends the given values at the end of the DataColumn
+      #
+      # @todo This isn't very efficient. Does it really matter ?
+      def push_values(value, min=nil, max=nil)
+        set_values_at(@values.size, value, min, max)
+      end
+
       # Creates dummy errors (ie, min_values = max_values = values) if
       # the datacolumn does not currently have one.
       def ensure_has_errors
@@ -158,13 +204,15 @@ module CTioga2
         set_vectors(new_vects)
       end
 
-      ColumnSpecsRE = /|min|max/i
+      ColumnSpecsRE = /|min|max|err/i
 
       # This function sets the value of the DataColumn object
       # according to a hash: _spec_ => _vector_.  _spec_ can be any of:
       # * 'value', 'values' or '' : the #values
       # * 'min' : #min
       # * 'max' : #max
+      # * 'err' : absolute error: min is value - error, max is value +
+      #    error
       def from_hash(spec)
         s = spec.dup
         @values = spec['value'] || spec['values'] || 
@@ -181,6 +229,9 @@ module CTioga2
             @min_values = s[key]
           when /^max$/i
             @max_values = s[key]
+          when /^err$/i
+            @min_values = @values - s[key]
+            @max_values = @values + s[key]
           else
             raise "Unkown key: #{key}"
           end
@@ -223,6 +274,14 @@ module CTioga2
         end
         return m
       end
+
+      def convolve!(kernel, middle = nil)
+        middle ||= kernel.size/2
+        # We smooth everything, stupidly?
+        for v in all_vectors
+          v.replace(v.convolve(kernel,middle)) if v
+        end
+      end
       
       protected
 

data/lib/ctioga2/data/dataset.rb

@@ -1,5 +1,5 @@
 # dataset.rb: a class holding *one* dataset
-# copyright (c) 2009 by Vincent Fourmond
+# copyright (c) 2009-2011 by Vincent Fourmond
   
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -13,13 +13,14 @@
 
 require 'ctioga2/utils'
 require 'ctioga2/data/datacolumn'
+require 'ctioga2/data/indexed-dtable'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 81 $', '$Date: 2009-06-11 21:14:59 +0200 (Thu, 11 Jun 2009) $')
+  Version::register_svn_info('$Revision: 233 $', '$Date: 2011-01-20 10:26:42 +0100 (Thu, 20 Jan 2011) $')
 
 
-  # TODO: now, port the backend infrastructure...
+  # \todo now, port the backend infrastructure...
 
   # This module holds all the code that deals with manipulation and
   # acquisition of data of any sort.
@@ -53,6 +54,18 @@ module CTioga2
         @x = columns[0]
         @ys = columns[1..-1]
         @name = name
+
+        # Cache for the indexed dtable
+        @indexed_dtable = nil
+      end
+
+      # Creates a 
+      def self.create(name, number)
+        cols = []
+        number.times do
+          cols << Dobjects::Dvector.new()
+        end
+        return self.new(name, cols)
       end
 
       # Creates a new Dataset from a specification. This function
@@ -111,6 +124,11 @@ module CTioga2
         return @ys[1]
       end
 
+      # Returns true if X or Y columns have errors
+      def has_xy_errors?
+        return self.y.has_errors? || self.x.has_errors?
+      end
+
       # Sorts all columns according to X values
       def sort!
         idx_vector = Dobjects::Dvector.new(@x.values.size) do |i|
@@ -134,12 +152,13 @@ module CTioga2
         return retval
       end
 
-      # Iterates over all the values of the Dataset
-      def each_values
+      # Iterates over all the values of the Dataset.  Values of
+      # optional arguments are those of DataColumn::values_at.
+      def each_values(with_errors = false, expand_nil = true)
         @x.size.times do |i|
-          v = @x.values_at(i)
+          v = @x.values_at(i,with_errors, expand_nil)
           for y in @ys
-            v += y.values_at(i)
+            v += y.values_at(i,with_errors, expand_nil)
           end
           yield i, *v
         end
@@ -169,6 +188,25 @@ module CTioga2
         end
       end
 
+      # Appends the given values (as yielded by each_values(true)) to
+      # the stack. Elements of _values_ laying after the last
+      # DataColumn in the Dataset are simply ignored. Giving less than
+      # there should be will give interesting results.
+      def push_values(*values)
+        @x.push_values(*(values[0..2]))
+        @ys.size.times do |i|
+          @ys[i].push_values(*(values.slice(3*(i+1),3)))
+        end
+      end
+
+      # Almost the same thing as #push_values, but when you don't care
+      # about the min/max things.
+      def push_only_values(values)
+        @x.push_values(values[0])
+        @ys.size.times do |i|
+          @ys[i].push_values(values[i+1])
+        end
+      end
       
       # Modifies the dataset to only keep the data for which the block
       # returns true. The block should take the following arguments,
@@ -198,7 +236,7 @@ module CTioga2
       end
 
       # Same as #select!, but you give it a text formula instead of a
-      # block. It internall calls #select!, by the way ;-)...
+      # block. It internally calls #select!, by the way ;-)...
       def select_formula!(formula)
         names = @x.column_names('x', true)
         names.concat(@x.column_names('y', true))
@@ -216,7 +254,260 @@ module CTioga2
         select!(&block)
       end
 
-      # TODO: a dup !
+      # \todo a dup !
+
+      # Average all the non-X values of successive data points that
+      # have the same X values. It is a naive version that also
+      # averages the error columns.
+      def average_duplicates!
+        last_x = nil
+        last_x_first_idx = 0
+        xv = @x.values
+        i = 0
+        vectors = all_vectors
+        while i < xv.size
+          x = xv[i]
+          if ((last_x == x) && (i != (xv.size - 1)))
+            # Do nothing
+          else
+            if last_x_first_idx < (i - 1)  || 
+                ((last_x == x) && (i == (xv.size - 1)))
+              if i == (xv.size - 1)
+                e = i
+              else
+                e = i-1
+              end                 # The end of the slice.
+
+              ## \todo In real, to do this properly, one would
+              # have to write a proper function in DataColumn that
+              # does averaging over certain indices possibly more
+              # cleverly than the current way to do.
+              for v in vectors
+                subv = v[last_x_first_idx..e]
+                ave = subv.sum/subv.size
+                v.slice!(last_x_first_idx+1, e - last_x_first_idx)
+                v[last_x_first_idx] = ave
+              end
+              i -= e - last_x_first_idx
+            end
+            last_x = x
+            last_x_first_idx = i
+          end
+          i += 1
+        end
+        
+      end
+
+
+      # Returns an IndexedDTable representing the XYZ
+      # data. Information about errors are not included.
+      #
+      # @todo For performance, this will have to be turned into a real
+      # Dtable or Dvector class function. This function is just going
+      # to be *bad* ;-)
+      #
+      # @todo The cache should be invalidated when the contents of the
+      # Dataset changes (but that will be *real* hard !)
+      def indexed_table
+        if @indexed_dtable
+          return @indexed_dtable
+        end
+        # We convert the index into three x,y and z arrays
+        x = @x.values.dup
+        y = @ys[0].values.dup
+        z = @ys[1].values.dup
+        
+        xvals = x.sort.uniq
+        yvals = y.sort.uniq
+        
+        # Now building reverse hashes to speed up the conversion:
+        x_index = {}
+        i = 0
+        xvals.each do |v|
+          x_index[v] = i
+          i += 1
+        end
+
+        y_index = {}
+        i = 0
+        yvals.each do |v|
+          y_index[v] = i
+          i += 1
+        end
+
+        table = Dobjects::Dtable.new(xvals.size, yvals.size)
+        # We initialize all the values to NaN
+        table.set(0.0/0.0)
+        
+        x.each_index do |i|
+          ix = x_index[x[i]]
+          iy = y_index[y[i]]
+          # Y first !
+          table[iy, ix] = z[i]
+        end
+        @indexed_dtable = IndexedDTable.new(xvals, yvals, table)
+        return @indexed_dtable
+      end
+
+      # Returns a x,y Function 
+      def make_contour(level)
+        dtable = indexed_table
+        x,y,gaps = *dtable.make_contour(level)
+        n = 0.0/0.0
+        gaps.sort.reverse.each do |i|
+          x.insert(i-1,n)
+          y.insert(i-1,n)
+        end
+        return Dobjects::Function.new(x,y)
+      end
+
+      # Smooths the data using a naive gaussian-like convolution (but
+      # not exactly). Not for use for reliable data filtering.
+      def naive_smooth!(number)
+        kernel = Dobjects::Dvector.new(number) { |i|
+          Utils.cnk(number,i)
+        }
+        mid = number - number/2 - 1
+        for y in @ys
+          y.convolve!(kernel, mid)
+        end
+      end
+
+      # Returns a hash of Datasets indexed on the values of the
+      # columns _cols_. Datasets contain the same number of columns.
+      def index_on_cols(cols = [2])
+        # Transform column number into index in the each_values call
+        cols.map! do |i|
+          i*3 
+        end
+
+        datasets = {}
+        self.each_values(true) do |i,*values|
+          signature = cols.map do |i|
+            values[i]
+          end
+          datasets[signature] ||= Dataset.create(name, self.size)
+          datasets[signature].push_values(*values)
+        end
+        return datasets
+      end
+
+      
+      # Massive linear regressions over all X and Y values
+      # corresponding to a unique set of all the other Y2... Yn
+      # values.
+      #
+      # Returns the [coeffs, lines]
+      #
+      # @todo Have the possibility to elaborate on the regression side
+      # (in particular force b to 0)
+      def reglin(options = {})
+        cols = []
+        2.upto(self.size-1) do |i|
+          cols << i
+        end
+        datasets = index_on_cols(cols)
+
+        # Create two new datasets:
+        # * one that collects the keys and a,b
+        # * another that collects the keys and x1,y1, x2y2
+        coeffs = Dataset.create("coefficients", self.size)
+        lines = Dataset.create("lines", self.size)
+
+        for k,v in datasets
+          f = Dobjects::Function.new(v.x.values, v.y.values)
+          if options['linear']  # Fit to y = a*x
+            d = f.x.dup
+            d.mul!(f.x)
+            sxx = d.sum
+            d.replace(f.x)
+            d.mul!(f.y)
+            sxy = d.sum
+            a = sxy/sxx
+            coeffs.push_only_values(k + [a,0])
+            lines.push_only_values(k + [f.x.min, a * f.x.min])
+            lines.push_only_values(k + [f.x.max, a * f.x.max])
+          else
+            a,b = f.reglin
+            coeffs.push_only_values(k + [a, b])
+            lines.push_only_values(k + [f.x.min, b + a * f.x.min])
+            lines.push_only_values(k + [f.x.max, b + a * f.x.max])
+          end
+          
+        end
+
+        return [coeffs, lines]
+      end
+
+      # Merges one or more other data sets into this one; one or more
+      # columns are designated as "master" columns and their values
+      # must match in all datasets. Extra columns are simply appended,
+      # in the order in which the datasets are given
+      #
+      # Comparisons between the values are made in abritrary precision
+      # unless precision is given, in which case values only have to
+      # match to this given number of digits.
+      #
+      # @todo update column names.
+      #
+      # @todo write provisions for column names, actually ;-)...
+      def merge_datasets_in(datasets, columns = [0], precision = nil)
+        # First thing, the data precision block:
+
+        prec = if precision then
+                 proc do |x|
+            ("%.#{@precision}g" % x) # This does not need to be a Float
+          end
+               else
+                 proc {|x| x}   # For exact comparisons
+               end
+
+        # First, we build an index of the master columns of the first
+        # dataset.
+
+        hash = {}
+        self.each_values(false) do |i, *cols|
+          signature = columns.map {|j|
+            prec.call(cols[j])
+          }
+          hash[signature] = i
+        end
+
+        remove_indices = columns.sort.reverse
+
+        for set in datasets
+          old_columns = set.all_columns
+          for i in remove_indices
+            old_columns.slice!(i)
+          end
+
+          # Now, we got rid of the master columns, we add the given
+          # number of columns
+
+          new_columns = []
+          old_columns.each do |c|
+            new_columns << DataColumn.create(@x.size, c.has_errors?)
+          end
+
+          set.each_values(false) do |i, *cols|
+            signature = columns.map {|j|
+              prec.call(cols[j])
+            }
+            idx = hash[signature]
+            if idx
+              old_columns.each_index  { |j|
+                new_columns[j].
+                set_values_at(idx, 
+                              * old_columns[j].values_at(i, true, true))
+              }
+            else
+              # Data points are lost
+            end
+          end
+          @ys.concat(new_columns)
+        end
+
+      end
 
       protected
 
@@ -224,6 +515,11 @@ module CTioga2
       def all_columns
         return [@x, *@ys]
       end
+
+      # Returns all Dvectors of the columns one by one.
+      def all_vectors
+        return all_columns.map {|x| x.vectors}.flatten(1)
+      end
       
     end