ctioga2 0.0

data/lib/ctioga2/data/backends/parameter.rb

@@ -0,0 +1,109 @@
+# parameter.rb : A class to describe a parameter
+# Copyright (C) 2006 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program 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 General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+require 'ctioga2/utils'
+
+require 'ctioga2/metabuilder/type'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 17 $', '$Date: 2009-04-28 22:22:22 +0200 (Tue, 28 Apr 2009) $')
+
+  module Data
+
+    module Backends
+
+      # A parameter describes a way of storing some information into an
+      # instance of an object. No type checking is done on the target object
+      # when the actual reading/writing is done. However, the type checking
+      # is done upstream by the Description system.
+      #
+      # A Parameter consists of several things:
+      #
+      # * a #name, to identify it in a unique fashion;
+      # * a #type, used to convert to and from String and for user
+      #   interaction in general;
+      # * some explanative text, used to inform the user: #long_name and
+      #   #description
+      # * two symbols that are used to gain read and write access of the
+      #   parameter on the target object.
+      #
+      # The Parameter class can be used to maintain a set of
+      # meta-informations about types in a given object.
+      class Parameter 
+        
+        # The short name of the parameter
+        attr_accessor :name
+        
+        # The long name of the parameter, to be translated
+        attr_accessor :long_name
+        
+        # The function names that should be used to set the symbol and
+        # retrieve it's current value. The corresponding functions should
+        # read or return a string, and writer(reader) should be a noop.
+        attr_accessor :reader_symbol, :writer_symbol
+        
+        # The (text) description of the parameter
+        attr_accessor :description
+        
+        # The actual Commands::CommandType of the parameter
+        attr_accessor :type
+
+        # Creates a new Parameter with the given symbols. Remember that
+        # if you don't intend to use #get, #get_raw, #set and #set_raw,
+        # you don't need to pass meaningful values to _writer_symbol_ and
+        # _reader_symbol_. 
+        def initialize(name, writer_symbol,
+                       reader_symbol,
+                       long_name, type,
+                       description)
+          @name = name
+          @writer_symbol = writer_symbol
+          @reader_symbol = reader_symbol
+          @description = description
+          @long_name = long_name
+          @type = Commands::CommandType::get_type(type)
+        end
+
+
+        # Sets directly the target parameter, without type conversion
+        def set_value(target, val)
+          target.send(@writer_symbol, val) 
+        end
+        
+        # Uses the #writer_symbol of the _target_ to set the value of the
+        # parameter to the one converted from the String _str_
+        def set_from_string(target, str)
+          set_value(target, string_to_type(str)) 
+        end
+        
+
+        # Aquires the value from the backend, and returns it in the
+        # form of a string
+        def get_string(target)
+          return type_to_string(get_value(target))
+        end
+
+        # Aquires the value from the backend, and returns it.
+        def get_value(target)
+          target.send(@reader_symbol)
+        end
+
+      end
+    end
+  end
+end

data/lib/ctioga2/data/datacolumn.rb

@@ -0,0 +1,245 @@
+# datacolumn.rb: a class holding a 'column' of data
+# copyright (c) 2009 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program 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 General Public License for more details (in the COPYING file).
+
+require 'Dobjects/Dvector'
+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) $')
+
+  module Data
+
+    # This class holds one column, possibly with error bars.
+    #
+    # TODO: a way to concatenate two DataColumns
+    #
+    # TODO: a way to easily access the by "lines"
+    class DataColumn
+      
+      # A Dvector holding ``real'' values
+      attr_accessor :values
+      
+      # A Dvector holding minimal values
+      attr_accessor :min_values
+
+      # A Dvector holding maximal values
+      attr_accessor :max_values
+
+      # 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 !
+
+      def initialize(values, min = nil, max = nil)
+        @values = values
+        @min_values = min
+        @max_values = max
+      end
+
+
+      # Yields all the vectors in turn to apply a given
+      # transformation.
+      def apply
+        for v in all_vectors
+          yield v if v
+        end
+      end
+
+      # Sorts the values according to the index vector given.
+      def reindex(idx_vector)
+        for v in all_vectors
+          # This is slow !
+          # Code should be written in C on the dvector side.
+          #
+          # Or we could use Function.sort, though this is not very
+          # elegant nor efficient. (but it would be memory-efficient,
+          # though).
+          next unless v
+          w = Dobjects::Dvector.new(idx_vector.size) do |i|
+            v[idx_vector[i]]
+          end
+          v.replace(w)
+        end
+      end
+
+      # Whether there are error bars.
+      def has_errors?
+        return (@min_values && @max_values)
+      end
+
+      # Column names. _base_ is used as a base for the names. If
+      # _expand_ is on, always return all the names.
+      def column_names(base, expand = false)
+        if expand || has_errors?
+          return [base, "#{base}min", "#{base}max"]
+        else
+          return [base]
+        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)
+        if has_errors?
+          return [@values[i], @min_values[i], @max_values[i]]
+        else
+          if expand
+            return [@values[i], @values[i], @values[i]]
+          else
+            return [@values[i]]
+          end
+        end
+      end
+
+      # Returns the number of elements.
+      def size
+        return @values.size
+      end
+
+      # Creates dummy errors (ie, min_values = max_values = values) if
+      # the datacolumn does not currently have one.
+      def ensure_has_errors
+        if ! has_errors?
+          @min_values = @values.dup
+          @max_values = @values.dup
+        end
+      end
+
+      # Concatenates with another DataColumn, making sure the errors
+      # and such are not lost.
+      def <<(column)
+        # If there are error bars, wew make sure we concatenate all of them
+        if has_errors? || column.has_errors?
+          self.ensure_has_errors
+          column.ensure_has_errors
+          @min_values.concat(column.min_values)
+          @max_values.concat(column.max_values)
+        end
+        @values.concat(column.values)
+      end
+
+      # Only keeps every _n_ points in the DataColumn
+      def trim!(nb)
+        nb = nb.to_i
+        if nb < 2
+          return
+        end
+
+        new_vects = []
+        for v in all_vectors
+          if v
+            new_values = Dobjects::Dvector.new
+            i = 0
+            for val in v
+              if (i % nb) == 0
+                new_values << val
+              end
+              i+=1
+            end
+            new_vects << new_values
+          else
+            new_vects << nil
+          end
+        end
+        set_vectors(new_vects)
+      end
+
+      ColumnSpecsRE = /|min|max/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
+      def from_hash(spec)
+        s = spec.dup
+        @values = spec['value'] || spec['values'] || 
+          spec[''] 
+        if ! @values
+          raise "Need a 'value' specification"
+        end
+        for k in ['value', 'values', '']
+          s.delete(k)
+        end
+        for key in s.keys
+          case key
+          when /^min$/i
+            @min_values = s[key]
+          when /^max$/i
+            @max_values = s[key]
+          else
+            raise "Unkown key: #{key}"
+          end
+        end
+      end
+
+
+      # Creates and returns a DataColumn object according to the
+      # _spec_. See #from_hash for more information.
+      def self.from_hash(spec)
+        a = DataColumn.new(nil)
+        a.from_hash(spec)
+        return a
+      end
+
+      # Returns the minimum value of all vectors held in this column
+      def min
+        m = @values.min
+        for v in [@min_values, @max_values]
+          if v
+            m1 = v.min
+            if m1 < m           # This also works if m1 is NaN
+              m = m1
+            end
+          end
+        end
+        return m
+      end
+
+      # Returns the maximum value of all vectors held in this column
+      def max
+        m = @values.max
+        for v in [@min_values, @max_values]
+          if v
+            m1 = v.max
+            if m1 > m           # This also works if m1 is NaN
+              m = m1
+            end
+          end
+        end
+        return m
+      end
+      
+      protected
+
+      # All the vectors held by the DataColumn
+      def all_vectors
+        return [@values, @min_values, @max_values]
+      end
+
+      # Sets the vectors to the given list, as might have been
+      # returned by #all_vectors
+      def set_vectors(vectors)
+        @values, @min_values, @max_values = *vectors
+      end
+
+    end
+
+  end
+
+end
+

data/lib/ctioga2/data/dataset.rb

@@ -0,0 +1,233 @@
+# dataset.rb: a class holding *one* dataset
+# copyright (c) 2009 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program 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 General Public License for more details (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'ctioga2/data/datacolumn'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 81 $', '$Date: 2009-06-11 21:14:59 +0200 (Thu, 11 Jun 2009) $')
+
+
+  # TODO: now, port the backend infrastructure...
+
+  # This module holds all the code that deals with manipulation and
+  # acquisition of data of any sort.
+  module Data
+
+    # This is the central class of the data manipulation in ctioga.
+    # It is a series of 'Y' DataColumn indexed on a unique 'X'
+    # DataColumn. This can be used to represent multiple XY data sets,
+    # but also XYZ and even more complex data. The actual
+    # signification of the various 'Y' columns are left to the user.
+    class Dataset
+
+      # The X DataColumn
+      attr_accessor :x
+
+      # All Y DataColumn (an Array of DataColumn)
+      attr_accessor :ys
+
+      # The name of the Dataset, such as one that could be used in a
+      # legend (like for the --auto-legend option of ctioga).
+      attr_accessor :name
+
+      # Creates a new Dataset object with the given data columns
+      # (Dvector or DataColumn). #x is the first one
+      def initialize(name, columns)
+        columns.each_index do |i|
+          if columns[i].is_a? Dobjects::Dvector
+            columns[i] = DataColumn.new(columns[i])
+          end
+        end
+        @x = columns[0]
+        @ys = columns[1..-1]
+        @name = name
+      end
+
+      # Creates a new Dataset from a specification. This function
+      # parses a specification in the form of:
+      # * a:b{:c}+
+      # * spec=a{:spec2=b}+
+      #
+      # It yields each of the unprocessed text, not necessarily in the
+      # order they were read, and expects a Dvector as a return value.
+      #
+      # It then builds a suitable Dataset object with these values,
+      # and returns it.
+      #
+      # It is *strongly* *recommended* to use this function for
+      # reimplementations of Backends::Backend#query_dataset.
+      def self.dataset_from_spec(name, spec)
+        specs = []
+        i = 0
+        for s in spec.split(/:/)
+          if s =~ /^(x|y\d*|z)(#{DataColumn::ColumnSpecsRE})=(.*)/i
+            which, mod, s = $1.downcase,($2 && $2.downcase) || "value",$3
+            
+            case which
+            when /x/
+              idx = 0
+            when /y(\d+)?/
+              if $1
+                idx = $1.to_i
+              else
+                idx = 1
+              end
+            when /z/
+              idx = 2
+            end
+            specs[idx] ||= {}
+            specs[idx][mod] = yield s
+          else
+            specs[i] = {"value" =>  yield(s)}
+          end
+          i += 1
+        end
+        columns = []
+        for s in specs
+          columns << DataColumn.from_hash(s)
+        end
+        return Dataset.new(name, columns)
+      end
+
+      # The main Y column (ie, the first one)
+      def y
+        return @ys[0]
+      end
+
+      # The Z column, if applicable
+      def z
+        return @ys[1]
+      end
+
+      # Sorts all columns according to X values
+      def sort!
+        idx_vector = Dobjects::Dvector.new(@x.values.size) do |i|
+          i
+        end
+        f = Dobjects::Function.new(@x.values.dup, idx_vector)
+        f.sort
+        # Now, idx_vector contains the indices that make X values
+        # sorted.
+        for col in all_columns
+          col.reindex(idx_vector)
+        end
+      end
+
+      # Returns an array with Column names.
+      def column_names
+        retval = @x.column_names("x")
+        @ys.each_index do |i|
+          retval += @ys[i].column_names("y#{i+1}")
+        end
+        return retval
+      end
+
+      # Iterates over all the values of the Dataset
+      def each_values
+        @x.size.times do |i|
+          v = @x.values_at(i)
+          for y in @ys
+            v += y.values_at(i)
+          end
+          yield i, *v
+        end
+      end
+
+      # The overall number of columns
+      def size
+        return 1 + @ys.size
+      end
+
+      # Concatenates another Dataset to this one
+      def <<(dataset)
+        if dataset.size != self.size
+          raise "Can't concatenate datasets that don't have the same number of columns: #{self.size} vs #{dataset.size}"
+        end
+        @x << dataset.x
+        @ys.size.times do |i|
+          @ys[i] << dataset.ys[i]
+        end
+      end
+
+
+      # Trims all data columns. See DataColumn#trim!
+      def trim!(nb)
+        for col in all_columns
+          col.trim!(nb)
+        end
+      end
+
+      
+      # Modifies the dataset to only keep the data for which the block
+      # returns true. The block should take the following arguments,
+      # in order:
+      #
+      # _x_, _xmin_, _xmax_, _y_, _ymin_, _ymax_, _y1_, _y1min_, _y1max_,
+      #  _z_, _zmin_, _zmax_, _y2_, _y2min_, _y2max_, _y3_, _y3min_, _y3max_
+      #
+      def select!(&block)
+        target = []
+        @x.size.times do |i|
+          args = @x.values_at(i, true)
+          args.concat(@ys[0].values_at(i, true) * 2)
+          if @ys[1]
+            args.concat(@ys[1].values_at(i, true) * 2)
+            for yvect in @ys[2..-1]
+              args.concat(yvect.values_at(i, true))
+            end
+          end
+          if block.call(*args)
+            target << i
+          end
+        end
+        for col in all_columns
+          col.reindex(target)
+        end
+      end
+
+      # Same as #select!, but you give it a text formula instead of a
+      # block. It internall calls #select!, by the way ;-)...
+      def select_formula!(formula)
+        names = @x.column_names('x', true)
+        names.concat(@x.column_names('y', true))
+        names.concat(@x.column_names('y1', true))
+        if @ys[1]
+          names.concat(@x.column_names('z', true))
+          names.concat(@x.column_names('y2', true))
+          i = 3
+          for yvect in @ys[2..-1]
+            names.concat(@x.column_names("y#{i}", true))
+            i += 1
+          end
+        end
+        block = eval("proc do |#{names.join(',')}|\n#{formula}\nend")
+        select!(&block)
+      end
+
+      # TODO: a dup !
+
+      protected
+
+      # Returns all DataColumn objects held by this Dataset
+      def all_columns
+        return [@x, *@ys]
+      end
+      
+    end
+
+  end
+
+end
+