ctioga2 0.4 → 0.5

data/lib/ctioga2/commands/parsers/old-file.rb

@@ -0,0 +1,191 @@
+# old-file.rb: a file parser for ctioga2
+# copyright (c) 2009, 2013 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 'stringio'
+require 'ctioga2/utils'
+require 'ctioga2/log'
+require 'ctioga2/commands/commands'
+require 'ctioga2/commands/strings'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 392 $', '$Date: 2013-06-23 01:05:02 +0200 (Sun, 23 Jun 2013) $')
+
+  module Commands
+
+    module Parsers
+
+      # Raised when EOF is encountered during a symbol parsing
+      class UnterminatedSymbol < Exception
+      end
+
+      # Unexepected character.
+      class UnexpectedCharacter < Exception
+      end
+
+      # Syntax error
+      class ParserSyntaxError < Exception
+      end
+
+      # This class is in charge of parsing a "old style" command file.
+      class OldFileParser
+
+        include Log
+
+        # Runs a command file targeting the given _interpreter_.
+        def self.run_command_file(file, interpreter)
+          OldFileParser.new.run_command_file(file, interpreter)
+        end
+
+        # Runs the given command strings
+        def self.run_commands(strings, interpreter)
+          OldFileParser.new.run_commands(strings, interpreter)
+        end
+
+        # Runs a command file targeting the given _interpreter_.
+        def run_command_file(file, interpreter)
+          f = open(file)
+          parse_io_object(f, interpreter)
+        end
+
+        # Runs the given command strings
+        def run_commands(strings, interpreter)
+          io = StringIO.new(strings)
+          parse_io_object(io, interpreter)
+        end
+
+        # Parses a given _io_ object, sending commands/variable
+        # definitions to the given _interpreter_.
+        def parse_io_object(io, interpreter)
+          # The process is simple: we look for symbols and
+          # corresponding syntax element: parentheses or assignments
+
+          ## @todo It would be really great if assignments could be
+          ## made conditional (a bit like in makefiles)
+          while(1)
+            symbol = up_to_next_symbol(io)
+            break if not symbol
+            
+            while(1)
+              c = io.getc
+              if ! c              # EOF
+                raise ParserSyntaxError, "Expecting something after symbol #{symbol}"
+              end
+              ch = c.chr
+              if ch =~ /\s/      # blank...
+                next
+              elsif ch == '('    # beginning of a function call
+                # Parse string:
+                str = InterpreterString.parse_until_unquoted(io,")")
+                # Now, we need to split str.
+                args = str.expand_and_split(/\s*,\s*/, interpreter)
+
+                cmd = interpreter.get_command(symbol)
+                real_args = args.slice!(0, cmd.argument_number)
+                # And now the options:
+                options = {}
+
+                # Problem: the space on the right of the = sign is
+                # *significant*. 
+                for o in args
+                  if o =~ /^\s*\/?([\w-]+)\s*=(.*)/
+                    if cmd.has_option? $1
+                      options[$1] = $2
+                    else
+                      error { 
+                        "Command #{cmd.name} does not take option #{$1}" 
+                      }
+                    end
+                  end
+                end
+
+                interpreter.context.parsing_file(symbol, io) # Missing line number
+                interpreter.run_command(cmd, real_args, options)
+                io.getc         # Slurp up the )
+                break
+              elsif ch == ':'   # Assignment
+                c = io.getc
+                if ! c          # EOF
+                  raise ParserSyntaxError, "Expecting = after :"
+                end
+                ch = c.chr
+                if ch != '='
+                  raise ParserSyntaxError, "Expecting = after :"
+                end
+                str = InterpreterString.parse_until_unquoted(io,"\n", false)
+                interpreter.variables.define_variable(symbol, str, 
+                                                      interpreter)
+                break
+              elsif ch == '='
+                str = InterpreterString.parse_until_unquoted(io,"\n", false)
+                interpreter.variables.define_variable(symbol, str, nil) 
+                break
+              else
+                raise UnexpectedCharacter, "Did not expect #{ch} after #{symbol}"
+              end
+            end
+          end
+        end
+
+        protected
+
+        SYMBOL_CHAR_REGEX = /[a-zA-Z0-9_-]/
+        
+        # Parses the _io_ stream up to and including the next
+        # symbol. Only white space or comments may be found on the
+        # way. This function returns the symbol.
+        #
+        # Symbols are composed of the alphabet SYMBOL_CHAR_REGEX.
+        def up_to_next_symbol(io)
+
+          symbol = nil          # As long as no symbol as been started
+          # it will stay nil.
+          while(1)
+            c = io.getc
+            if ! c              # EOF
+              if symbol
+                raise UnterminatedSymbol, "EOF reached during symbol parsing"
+              else
+                # File is finished and we didn't meet any symbol.
+                # Nothing to do !
+                return nil
+              end
+            end
+            ch = c.chr
+            if symbol           # We have started
+              if ch =~ SYMBOL_CHAR_REGEX
+                symbol += ch
+              else
+                io.ungetc(c)
+                return symbol
+              end
+            else
+              if ch =~ SYMBOL_CHAR_REGEX
+                symbol = ch
+              elsif ch =~ /\s/
+                # Nothing
+              elsif ch == '#'
+                io.gets
+              else
+                raise UnexpectedCharacter, "Unexpected character: #{ch}, when looking for a symbol"
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/ctioga2/commands/strings.rb

@@ -16,7 +16,7 @@ require 'stringio'              # For debugging purposes
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+  Version::register_svn_info('$Revision: 400 $', '$Date: 2013-08-19 17:29:57 +0200 (Mon, 19 Aug 2013) $')
 
   module Commands
 
@@ -256,7 +256,7 @@ module CTioga2
             cur_str += value
           when :unquoted
             tmp = value.split(re, -1)
-            cur_str += tmp[0]
+            cur_str += tmp[0] if tmp.size > 0
             # Push splitted stuff here:
             while tmp.size > 1
               retval << cur_str

data/lib/ctioga2/data/datacolumn.rb

@@ -17,7 +17,7 @@ require 'ctioga2/utils'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 229 $', '$Date: 2011-01-17 17:34:57 +0100 (Mon, 17 Jan 2011) $')
+  Version::register_svn_info('$Revision: 402 $', '$Date: 2013-08-19 17:30:02 +0200 (Mon, 19 Aug 2013) $')
 
   module Data
 
@@ -204,7 +204,7 @@ module CTioga2
         set_vectors(new_vects)
       end
 
-      ColumnSpecsRE = /|min|max|err/i
+      ColumnSpecsRE = /|min|max|err|rerr/i
 
       # This function sets the value of the DataColumn object
       # according to a hash: _spec_ => _vector_.  _spec_ can be any of:
@@ -232,6 +232,9 @@ module CTioga2
           when /^err$/i
             @min_values = @values - s[key]
             @max_values = @values + s[key]
+          when /^rerr$/i
+            @min_values = @values *(1 - s[key])
+            @max_values = @values *(1 + s[key])
           else
             raise "Unkown key: #{key}"
           end

data/lib/ctioga2/data/dataset.rb

@@ -18,7 +18,7 @@ require 'ctioga2/data/indexed-dtable'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 304 $', '$Date: 2012-01-03 15:06:33 +0100 (Tue, 03 Jan 2012) $')
+  Version::register_svn_info('$Revision: 406 $', '$Date: 2013-08-22 21:23:44 +0200 (Thu, 22 Aug 2013) $')
 
 
   # \todo now, port the backend infrastructure...
@@ -393,18 +393,8 @@ module CTioga2
       #
       # @todo add algorithm
       def make_contour(level)
-        dtable = indexed_table
-        x,y,gaps = *dtable.make_contour(level)
-
-        # We remove any gap corresponding to the element size,
-        # meaningless.
-        gaps -= [x.size]
-        n = 0.0/0.0
-        gaps.sort.reverse.each do |i|
-          x.insert(i,n)
-          y.insert(i,n)
-        end
-        return Dobjects::Function.new(x,y)
+        table = indexed_table
+        return table.make_contour(level, {'ret' => 'func'} )
       end
 
       # Smooths the data using a naive gaussian-like convolution (but

data/lib/ctioga2/data/indexed-dtable.rb

@@ -15,7 +15,7 @@ require 'ctioga2/utils'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 181 $', '$Date: 2010-10-27 15:18:35 +0200 (Wed, 27 Oct 2010) $')
+  Version::register_svn_info('$Revision: 406 $', '$Date: 2013-08-22 21:23:44 +0200 (Thu, 22 Aug 2013) $')
 
 
   module Data
@@ -114,19 +114,51 @@ module CTioga2
         return @y_values.size
       end
 
-      # Returns a [xs, ys, gaps] triplet suitable for use with
-      # t.append_points_with_gaps_to_path to show the given level.
+      # Makes a contour using the given level.
       #
-      # @todo add algorithm choice too
-      def make_contour(level)
+      # Depending on the value of opts['ret'], what is returned is:
+      # * if 'xyg', [xs, ys, gaps] triplet suitable for use with
+      #   t.append_points_with_gaps_to_path to show the
+      #   given level (default)
+      # * if 'func', a single function with nans inserted
+      #   at the position of the gaps
+      # * if 'funcs', a function for each of the "continuous" segments
+      #
+      # Anything else in opts is given directly to make_contour
+      def make_contour(level, opts = {})
         gaps = []
         # Requires Tioga r598
-        xs, ys = *Tioga::FigureMaker.make_contour('data' => @table,
-                                                  'xs' => @x_values, 
-                                                  'ys' => @y_values,
-                                                  'gaps' => gaps,
-                                                  'level' => level)
-        return  [xs, ys, gaps]
+        opts = {'data' => @table,
+          'xs' => @x_values, 
+          'ys' => @y_values,
+          'gaps' => gaps,
+          'level' => level
+        }.update(opts)
+
+        ret = opts['ret'] || 'xyg'
+        
+        opts.delete('ret')
+        xs, ys = *Tioga::FigureMaker.make_contour(opts)
+
+        if ret == 'xyg'
+          return  [xs, ys, gaps]
+        end
+
+        gaps = opts['gaps'].dup
+
+        gaps -= [xs.size]
+        n = 0.0/0.0
+        gaps.sort.reverse.each do |i|
+          xs.insert(i,n)
+          ys.insert(i,n)
+        end
+
+        fnc = Dobjects::Function.new(xs,ys)
+        if ret == 'func'
+          return fnc
+        else
+          return fnc.split_on_nan(:x)
+        end
       end
 
     end

data/lib/ctioga2/data/stack.rb

@@ -25,7 +25,7 @@ require 'ctioga2/data/filters'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 367 $', '$Date: 2012-12-28 16:14:52 +0100 (Fri, 28 Dec 2012) $')
+  Version::register_svn_info('$Revision: 390 $', '$Date: 2013-03-13 11:36:47 +0100 (Wed, 13 Mar 2013) $')
 
 
   module Data
@@ -121,28 +121,54 @@ module CTioga2
       # Returns the stored dataset, either using its index in the
       # stack, or its name in the dataset.
       def stored_dataset(spec)
+        return dataset_xref(spec)[0]
+      end
+
+
+      # Returns the [dataset, index, name] of the given dataset
+      def dataset_xref(spec)
+        ds = nil
+        index = nil
+        name = nil
         if spec.is_a? Numeric or spec =~ /^\s*-?\d+\s*$/
           spec = spec.to_i
-          return @stack[spec]
+          index = spec
+          name = nil
+          ds = @stack[index]
+          for k,v in @named_datasets
+            if v == ds
+              name = k
+            end
+          end
         else
           if @named_datasets.key? spec
-            return @named_datasets[spec]
+            name = spec
+            ds = @named_datasets[spec]
+            i = 0
+            for d in @stack
+              if d == ds
+                index = i
+              end
+              i += 1
+            end
           else
             raise "Unkown named dataset from the stack: '#{spec}'"
           end
         end
+        return [ds, index, name]
       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)
+      def specified_dataset(options, full = false)
         spec = if options && options['which']
                  options['which']
                else
                  -1
                end
-        return stored_dataset(spec)
+        xr = dataset_xref(spec)
+        return (full ? xr : xr[0])
       end
 
       # Adds a Dataset object onto the stack, running hooks if
@@ -250,11 +276,25 @@ module CTioga2
           
           pref = sprintf("#%-2d %-3d:", i, - @stack.size + i)
           
-          STDERR.puts " * #{pref} #{ds.name} -- #{ds.ys.size + 1} columns #{name}"
+          STDERR.puts " * #{pref} #{ds.name} -- #{ds.ys.size + 1} columns, #{ds.x.size} points #{name}"
           i += 1
         end
       end
 
+      # Drops the dataset corresponding to the given spec from the
+      # stack
+      def drop_from_stack(spec)
+        xr = dataset_xref(spec)
+        if xr[1]                # But that should always be the case ?
+          @stack.delete_at(xr[1])
+        else
+          warn { "For some reason, dataset '#{spec}' is not in the stack !"}
+        end
+        if xr[2]
+          @named_datasets.delete(xr[2])
+        end
+      end
+
       
     end
 
@@ -332,6 +372,23 @@ EOH
                               <<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
+
+
+    DropCommand =
+      Cmd.new("drop", nil, "--drop",
+              [CmdArg.new('stored-dataset')], { }) do |plotmaker,spec,opts|
+      plotmaker.data_stack.drop_from_stack(spec)
+    end
+    
+    DropCommand.describe("Drops the given dataset from the stack",
+                         <<EOH, DataStackGroup)
+Removes the given dataset from the stack. 
+
+Can become useful when dealing with large datasets, some of which are
+only used as intermediates for {command: apply-formula} or 
+{command: compute-contour}, for instance.
+
 EOH
 
     ConcatLastCommand = 
@@ -409,8 +466,8 @@ default the one before the last) into the last one. Data points that
 have no corresponding X value in the current dataset are simply
 ignored.
 
-This can be used to build 3D datasets for {cmd: xyz-map} or 
-{cmd: xy-parametric}.
+This can be used to build 3D datasets for {command: xyz-map} or 
+{command: xy-parametric}.
 EOH
 
     XYReglinCommand =