ctioga2 0.0

data/lib/ctioga2/data/filters.rb

@@ -0,0 +1,131 @@
+# stack.rb: the data stack
+# 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'
+require 'ctioga2/data/backends/backends'
+require 'ctioga2/data/backends/factory'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 82 $', '$Date: 2009-06-11 22:28:14 +0200 (Thu, 11 Jun 2009) $')
+
+
+  module Data
+
+    # A series of commands that can be used as "filters", as they act
+    # upon the last Dataset pushed unto the stack.
+    module Filters
+
+      FiltersGroup =  
+        CmdGroup.new('filter', "Filters",
+                     "The commands in this group act upon the last 
+dataset pushed unto the data stack: they can be viewed as filters.", 
+                     101)
+      
+      SortOperation = 
+        Cmd.new("sort-last", nil, "--sort-last", 
+                [], {}) do |plotmaker, opts|
+        plotmaker.data_stack.last.sort!
+      end
+      
+      SortOperation.describe("Sorts the last dataset according to X values",
+                             <<EOH, FiltersGroup)
+Sorts the last dataset pushed unto the stack according to X values. Can be
+used as a filter.
+
+See also {command: sort}.
+EOH
+
+      SortFilter = 
+        Cmd.new("sort", nil, "--sort", 
+                [], {}) do |plotmaker, opts|
+        plotmaker.data_stack.add_to_dataset_hook('sort-last()')
+      end
+      
+      SortFilter.describe("Systematically sort subsequent datasets",
+                          <<EOH, FiltersGroup)
+Install the {command: sort-last} command as a dataset hook (see {command:
+dataset-hook}): all subsequent datasets will be sorted according to
+their X values.
+EOH
+
+      TrimOperation = 
+        Cmd.new("trim-last", nil, "--trim-last", 
+                [CmdArg.new('integer')], {}) do |plotmaker, number, opts|
+        plotmaker.data_stack.last.trim!(number)
+      end
+      
+      TrimOperation.describe("Only keeps every n points in the last dataset",
+                             <<EOH, FiltersGroup)
+Only keeps one every ? data point on the last dataset pushed unto the
+data stack. Useful when data have too many points to avoid creating
+heavy PDF files that take ages to display with no additional benefits.
+
+This operation is very crude and does not average data.
+
+See also {command: trim}.
+EOH
+
+      TrimFilter = 
+        Cmd.new("trim", nil, "--trim", 
+                [CmdArg.new('integer')], {}) do |plotmaker, number, opts|
+        plotmaker.data_stack.add_to_dataset_hook("trim-last(#{number})")
+      end
+      
+      TrimFilter.describe("Systematically trim subsequent datasets",
+                          <<EOH, FiltersGroup)
+Install the {command: trim-last} command as a dataset hook (see {command:
+dataset-hook}): all subsequent datasets will be trimmed to keep only
+every n point.
+EOH
+
+
+      CherryPickOperation = 
+        Cmd.new("cherry-pick-last", nil, "--cherry-pick-last", 
+                [CmdArg.new('text')], {}) do |plotmaker, formula|
+        plotmaker.data_stack.last.select_formula!(formula)
+      end
+      
+      CherryPickOperation.describe("Removes data from the last dataset for which the formula is false",
+                                   <<EOH, FiltersGroup)
+
+Removes the data from the last dataset in the data stack for which the
+formula returns false.
+
+See also the {command: cherry-pick} command to apply the selection to
+all datasets.
+
+You might find it much easier to use the /where option of the
+{command: plot} or {command: load} commands.
+EOH
+
+      CherryPickFilter = 
+        Cmd.new("cherry-pick", nil, "--cherry-pick", 
+                [CmdArg.new('text')], {}) do |plotmaker, formula|
+        plotmaker.data_stack.add_to_dataset_hook("cherry-pick-last(#{formula})")
+      end
+      
+      CherryPickFilter.describe("Systematicallly remove data for which the formula is false",
+                                <<EOH, FiltersGroup)
+Install the {command: cherry-pick-last} command as a dataset hook (see
+{command: dataset-hook}): all points for which the formula returns
+false for subsequent datasets will be removed.
+EOH
+
+
+    end
+  end
+end
+

data/lib/ctioga2/data/merge.rb

@@ -0,0 +1,43 @@
+# stack.rb: the data stack
+# 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'
+require 'ctioga2/data/dataset'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 21 $', '$Date: 2009-04-30 14:11:53 +0200 (Thu, 30 Apr 2009) $')
+
+
+  module Data
+
+    # This module provides function to deal with the merging of
+    # several datasets.
+    module MergeDatasets
+
+      # Merges two or more datasets so that their X values match.  If
+      # _prec_ isn't _nil_, it is a Float which must not be greater
+      # than the difference between two X values that should be
+      # regarded as equal.
+      #
+      # TODO !
+      def merge_datasets(prec, *datasets)
+        
+      end
+
+    end
+  end
+end
+

data/lib/ctioga2/data/point.rb

@@ -0,0 +1,72 @@
+# point.rb: a point in a given 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'
+require 'ctioga2/data/dataset'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 76 $', '$Date: 2009-06-03 01:44:44 +0200 (Wed, 03 Jun 2009) $')
+
+
+  module Data
+
+    # This class represents a datapoint, ie. an index in a given
+    # DataSet.
+    class DataPoint
+
+      # The Dataset object the point is in
+      attr_accessor :dataset
+      
+      # The index of the data point within the Dataset
+      attr_accessor :index
+      
+      # Creates a DataPoint with the given information.
+      def initialize(index, dataset)
+      end
+
+      # Creates a DataPoint object based on the following _text_
+      # specification. It needs a reference to a _plotmaker_, since it
+      # accesses the data stack.
+      #
+      # Specification: ({_dataset_})?(_relative_|@_index_)
+      def self.from_text(plotmaker, text)
+        if text =~ /^(?:\s*\{([^}]+)\})?\s*(?:([.\d]+)|@(\d+))\s*$/
+          which = $1 || -1
+          if $2
+            rel = Float($2)
+          else
+            idx = $3.to_i
+          end
+          dataset = plotmaker.data_stack.stored_dataset(which)
+          if ! dataset
+            raise "Invalid or empty dataset: #{which}"
+          end
+          if rel
+            idx = (rel * dataset.x.values.size).to_i
+          end
+          return DataPoint.new(dataset, idx)
+        else
+          raise "Not a valid datapoint specification: '#{text}'"
+        end
+      end
+    end
+
+    # TODO: functions returning xy values + slope for the given
+    # datapoint. For each, possibility to average over several points.
+    
+  end
+
+end
+

data/lib/ctioga2/data/stack.rb

@@ -0,0 +1,294 @@
+# stack.rb: the data stack
+# 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'
+require 'ctioga2/data/dataset'
+require 'ctioga2/data/backends/backends'
+require 'ctioga2/data/backends/factory'
+
+require 'ctioga2/data/point'
+
+
+require 'ctioga2/data/filters'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 83 $', '$Date: 2009-06-11 23:18:35 +0200 (Thu, 11 Jun 2009) $')
+
+
+  module Data
+
+    # This is the central class for acquisition and handling of
+    # Dataset objects, retrieved from from a Backends::BackendFactory.
+    #
+    # TODO: provide real stack manipulation functions such as
+    # 
+    # * interpolation: pops the last object from the stack and add its
+    #   interpolated values on the element before.
+    # * mathematical functions on each column (DataColumn)
+    # * other stack-based operations.
+    class DataStack
+
+      include Log
+
+      # The array containing all the Dataset used so far.
+      attr_accessor :stack
+
+      # The BackendFactory used for retrieving data from named sets.
+      attr_accessor :backend_factory
+
+      # Named datasets
+      attr_accessor :named_datasets
+
+      # A hook executed every time a dataset is pushed unto the stack
+      # using #add_dataset.
+      #
+      # TODO: this string is parsed for each call to
+      # #add_dataset. Perhaps it would be good to provide a way to
+      # record a Command call, without parsing it from scratch ???
+      # 
+      # Although, with variables, that could be interesting to reparse
+      # everytime, since any change in the variables would be taken
+      # into account.
+      attr_accessor :dataset_hook
+
+      # Creates a new DataStack object.
+      def initialize
+        @stack = Array.new
+
+        @named_datasets = Hash.new
+
+        # Defaults to the 'text' backend
+        @backend_factory = Data::Backends::BackendFactory.new('text')
+      end
+
+      # Performs expansion on the given _set_ with the current
+      # backend, retrieves corresponding Dataset objects, pushes them
+      # onto the stack and returns them.
+      #
+      # _options_ is a Hash that can contain the options available to the
+      # 'load' command:
+      # 
+      # * 'name' to name each element added to the stack. A %d will be
+      #   replaced by the number of the dataset within the ones just
+      #   added.
+      #
+      # Additional members of the Hash are simply ignored.
+      def get_datasets(set, options = {})
+        backend = @backend_factory.current
+        retval = []
+        i = 0
+        for s in backend.expand_sets(set)
+          ds = backend.dataset(s)
+          add_dataset(ds, options['ignore_hooks'])
+
+          # Selection
+          if options['where']
+            ds.select_formula!(options['where'])
+          end
+
+          retval << ds
+          if options['name']
+            @named_datasets[options['name'] % [i]] = ds
+          end
+          i += 1
+        end
+        return retval
+      end
+
+      # Returns the stored dataset, either using its index in the
+      # stack, or its name in the dataset.
+      def stored_dataset(spec)
+        if spec.is_a? Numeric or spec =~ /^\s*-?\d+\s*$/
+          spec = spec.to_i
+          return @stack[spec]
+        else
+          if @named_datasets.key? spec
+            return @named_datasets[spec]
+          else
+            raise "Unkown named dataset from the stack: '#{spec}'"
+          end
+        end
+      end
+
+      # Gets a dataset from the given _options_ hash. If a 'which' key
+      # is present, it is used as an argument for #stored_dataset;
+      # else, -1 is used.
+      def specified_dataset(options)
+        spec = if options && options['which']
+                 options['which']
+               else
+                 -1
+               end
+        return stored_dataset(spec)
+      end
+
+      # Adds a Dataset object onto the stack, running hooks if
+      # necessary.
+      #
+      # Makes use of Plotmaker.plotmaker
+      def add_dataset(dataset, ignore_hooks = false)
+        @stack << dataset
+        if @dataset_hook && (! ignore_hooks)
+          # TODO: error handling
+          begin
+            PlotMaker.plotmaker.interpreter.run_commands(@dataset_hook)
+          rescue Exception => e
+            error "There was a problem running the dataset hook '#{@dataset_hook}', disabling it"
+            @dataset_hook = nil
+            info "-> '#{format_exception e}'"
+          end
+        end
+      end
+
+      # Appends a set of commands to the dataset hook
+      def add_to_dataset_hook(commands)
+        if @dataset_hook
+          @dataset_hook << "\n#{commands}"
+        else
+          @dataset_hook = commands
+        end
+      end
+
+      # Writes the contents of the the given _dataset_ (a DataSet
+      # object) to the given _io_ stream.
+      def print_dataset(dataset, io)
+        io.puts "# #{dataset.name}"
+        io.puts "# #{dataset.column_names.join("\t")}"
+        dataset.each_values do |i, *vals|
+          io.puts vals.join("\t")
+        end
+      end
+
+      # Pops the last _n_ datasets off the stack
+      def concatenate_datasets(n = 2)
+        ds = @stack.pop
+        raise "Nothing on the stack" unless ds
+        (n-1).times do
+          ds2 = @stack.pop
+          raise "Not enough datasets on the stack" unless ds2
+          ds << ds2
+        end
+        @stack.push(ds)
+      end
+
+      # Returns the last Dataset pushed onto the stack.
+      def last
+        return @stack.last
+      end
+
+      
+    end
+
+    DataStackGroup =  
+      CmdGroup.new('stack', "Data stack manipulation",
+                   "Commands for manipulation of the data stack", 
+                   100)
+
+    LoadDatasetOptions = { 
+      'name' => CmdArg.new('text'),
+      'where' => CmdArg.new('text'),
+      'ignore_hooks' => CmdArg.new('boolean')
+    }
+    
+    LoadDataCommand = 
+      Cmd.new("load", '-L', "--load", 
+              [ CmdArg.new('dataset'), ], 
+              LoadDatasetOptions) do |plotmaker, set, opts|
+      plotmaker.data_stack.get_datasets(set, opts)
+    end
+    
+    LoadDataCommand.describe("Load given sets onto the data stack",
+                             <<EOH, DataStackGroup)
+Use the current backend to load the given dataset(s) onto the data stack.
+
+If the name option is given, the last dataset loaded this way (if
+dataset expansion occurs) gets named, or, if it contains a %d (or
+similar construct), each dataset gets named with %d replace with the
+number of the dataset within the expansion (starting at 0). This name
+can be used to further use the dataset without remembering its
+number. See the type {type: stored-dataset} for more information.
+
+EOH
+
+
+    PrintLastCommand =
+      Cmd.new("print-dataset", '-P', "--print-dataset",
+              [], {'which' => CmdArg.new('stored-dataset')}) do |plotmaker,opts|
+      ds = plotmaker.data_stack.specified_dataset(opts)
+      plotmaker.data_stack.print_dataset(ds, STDOUT)
+    end
+    
+    PrintLastCommand.describe("Prints the dataset last pushed on the stack",
+                              <<EOH, DataStackGroup)
+Prints to standard output data contained in the last dataset pushed
+onto the stack, or the given stored dataset if the which option is given.
+EOH
+
+    ConcatLastCommand = 
+      Cmd.new("join-datasets", nil, "--join-datasets", 
+              [], {'number' => CmdArg.new('integer')}) do |plotmaker, opts|
+      nb = opts['number'] || 2
+      plotmaker.data_stack.concatenate_datasets(nb)
+    end
+    
+    ConcatLastCommand.describe("Concatenates the last datasets on the stack",
+                               <<EOH, DataStackGroup)
+Pops the last two (or number, if it is specified) datasets from the
+stack, concatenates them (older last) and push them back onto the
+stack.
+EOH
+
+    SetDatasetHookCommand = 
+      Cmd.new("dataset-hook", nil, "--dataset-hook", 
+              [CmdArg.new('commands')], {}) do |plotmaker, commands, opts|
+      plotmaker.data_stack.dataset_hook = commands
+    end
+    
+    SetDatasetHookCommand.describe("Sets the dataset hook",
+                                   <<EOH, DataStackGroup)
+The dataset hook is a series of commands such as those in the command
+files that are run every time after a dataset is added onto the data
+stack. Its main use is to provide automatic filtering of data, but any
+arbitrary command can be used, so enjoy !
+EOH
+
+    ClearDatasetHookCommand = 
+      Cmd.new("dataset-hook-clear", nil, "--dataset-hook-clear", 
+              [], {}) do |plotmaker, opts|
+      plotmaker.data_stack.dataset_hook = nil
+    end
+    
+    ClearDatasetHookCommand.describe("Clears the dataset hook",
+                                     <<EOH, DataStackGroup)
+Clears the dataset hook. See {command: dataset-hook} for more information.
+EOH
+
+    AddDatasetHookCommand = 
+      Cmd.new("dataset-hook-add", nil, "--dataset-hook-add", 
+              [CmdArg.new('commands')], {}) do |plotmaker, commands, opts|
+      plotmaker.data_stack.add_to_dataset_hook(commands)
+    end
+    
+    AddDatasetHookCommand.describe("Adds commands to the dataset hook",
+                                   <<EOH, DataStackGroup)
+Adds the given commands to the dataset hook. See {command: dataset-hook} 
+for more information about the dataset hook.
+EOH
+
+  end
+
+end
+