redshift 1.3.16 → 1.3.17

data/RELEASE-NOTES

@@ -1,3 +1,11 @@
+redshift 1.3.17
+
+- added shell example with plotting and tk animation
+
+- added supporting libs for tk and for irb shells
+
+- delay buffer automatically rotates around offset when dumping to array
+
 redshift 1.3.16
 
 - added util dir and modified requires to use libs from there

data/examples/shell.rb

@@ -0,0 +1,224 @@
+# Shows how to use a customized IRB shell to handle Ctrl-C interrupts
+
+require 'redshift'
+require 'redshift/mixins/irb-shell'
+include RedShift
+
+require 'redshift/util/plot'
+include Plot::PlotUtils
+
+# Adds an interactive ruby shell with plotting and animation commands.
+module ShellWorld
+  include RedShift::Shellable
+
+  def help
+    puts <<-END
+      The current object is #{self.inspect}. Some commands:
+
+        q         -- quit
+        sh!       -- enter a system command shell
+        t.plot    -- plot recent history of t (try t=components[0])
+        plot      -- plot recent history of all T instances
+        run N     -- run quickly for N time steps (integer)
+        evolve T  -- run quickly for T seconds (float)
+        tk        -- turn on Tk window
+        tk false  -- turn off Tk window
+
+      Local vars persist between interrupts.
+      Continue slow execution by pressing Ctrl-D (maybe Ctrl-Z on windows).
+      Press Ctrl-C again to break into the shell.
+    END
+  end
+  
+  def sh!
+    system ENV['SHELL'] || default_shell
+  end
+  
+  def default_shell
+    puts "No SHELL environment variable, trying /bin/bash"
+    "/bin/bash"
+  end
+  
+  def next_id
+    @next_id ||= 1
+    @next_id += 1
+  end
+  
+  def plot
+    gnuplot do |plot|
+      plot.command 'set title "recent history"'
+      plot.command "set xrange [*:*]"
+      plot.command "set yrange [*:*]"
+      grep(T) do |t|
+        t.add_history_to_plot(plot)
+      end
+    end
+    nil
+  end
+  
+  def before_shell
+    @tkar.catch_up_within 0 if @tkar
+    puts "\nStopped #{self.inspect}"
+  end
+  
+  def after_shell
+    @tkar.catch_up_within 0 if @tkar
+    puts "\nRunning #{self.inspect}"
+  end
+  
+  def dragger id, x, y
+    @th ||= {}
+    t = @th[id] ||= grep(T).find {|t| t.id == id}
+    t.x, t.y = x, y
+  end
+  
+  def tk turn_on = true
+    require 'redshift/util/tkar-driver'
+    if turn_on
+      if not @tkar or @tkar.closed?
+        @tkar = TkarDriver.new(method :dragger) do |pipe|
+          pipe.puts <<-END
+            title Animation example
+            background gray95
+            height 600
+            width 600
+            view_at -50 -50
+            zoom_to 4
+
+            shape cone \ arc5,5,10,10,fc:yellow,oc:black,extent:30,start:165,style:pieslice \
+    text2,2,anchor:c,justify:center,width:100,text:*0,fc:blue
+
+            shape circle oval*0,*0,*1,*1,oc:red
+          END
+          ## the view_at seems to be needed to overcome a little
+          ## centering bug in tkar
+
+          (1..10).each do |i|
+            pipe.puts "add circle #{next_id} - 0 0 0 0 #{5*i} #{-5*i}"
+          end
+
+          grep(T) do |t|
+            pipe.puts t.tk_add
+          end
+        end
+
+        tk_update
+      end
+      
+    elsif not turn_on and @tkar
+      @tkar.close
+      @tkar = nil
+    end
+    @tkar
+  end
+  
+  def tk_update
+    @tkar and @tkar.update do |pipe|
+      grep(T) do |t|
+        pipe.puts t.tk_update
+      end
+    end
+  end
+end
+
+class T < Component
+  attr_accessor :name, :id
+  
+  default do
+    @id = world.next_id
+  end
+  
+  flow do
+    diff " x' = -y "
+    diff " y' =  x "
+    
+    alg  " r = atan2(x, -y) " # atan2(y', x'): angle of velocity vector
+    
+    # A simple, but crude, way to store recent history of a var
+    delay " z = x ", :by => 10
+  end
+  
+  def history
+    ts = world.time_step
+    t0 = world.clock - z_delay
+    data = []
+    z_buffer_data.each_with_index do |xi, i|
+      if i % 4 == 0 # skip the integrator steps
+        time = t0 + (i/4)*ts
+        data << [time, xi] if time >= 0
+      end
+    end
+    data << [world.clock, x]
+    data
+  end
+  
+  def add_history_to_plot(plot)
+    plot.add history, "using 1:2 title \"#{name}.x\" with lines"
+  end
+
+  def plot
+    gnuplot do |plot|
+      plot.command 'set title "recent history"'
+      plot.command "set xrange [*:*]"
+      plot.command "set yrange [*:*]"
+      add_history_to_plot(plot)
+    end
+    nil
+  end
+
+  # return string that adds an instance of the shape with label t.name,
+  # position based on (x, y), and
+  # rotation based on (x', y')
+  def tk_add
+    "add cone #{id} - 10 #{x} #{y} #{r}\n" +
+    "param #{id} 0 #{name}"
+  end
+  
+  # emit string representing current state
+  def tk_update
+    "moveto #{id} #{x} #{y}\n" +
+    "rot #{id} #{r}"
+  end
+end
+
+w = World.new
+w.time_step = 0.01
+w.extend ShellWorld
+
+w.create T do |t|
+  t.name = "a"
+  t.x = 40
+  t.y = 0
+end
+w.create T do |t|
+  t.name = "b"
+  t.x = 0
+  t.y = 20
+end
+
+if false
+  (1..10).each do |i|
+    w.create T do |t|
+      t.name = "c#{i}"
+      t.x = i*5
+      t.y = i*5
+    end
+  end
+end
+
+puts "^C to break into shell; 'help' for shell help"
+
+if ARGV.delete "-t"
+  w.tk
+end
+
+start_in_shell = ARGV.delete "-s"
+w.shell.run if start_in_shell
+
+loop do
+  w.evolve 100000000 do
+    puts "clock: #{w.clock}"
+    w.tk_update
+    sleep 0.01
+  end
+end

data/lib/redshift/mixins/irb-shell.rb

@@ -0,0 +1,151 @@
+require 'irb'
+require 'irb/completion'
+
+class Object
+  include IRB::ExtendCommandBundle
+  # so that Marshal.dump still works, even when doing ">> irb obj"
+end
+
+def IRB.parse_opts
+  # Don't touch ARGV, which belongs to the app which called this module.
+end
+
+class RedShift::IRBShell
+  @@irb_setup_done = false
+  
+  # +args+ are binding, self (both optional)
+  def initialize(*args)
+    ## maybe set some opts here, as in parse_opts in irb/init.rb?
+
+    unless @@irb_setup_done
+      @@irb_setup_done = true
+
+      conf = IRB.conf
+      
+      if File.directory?("tmp")
+        conf[:HISTORY_FILE] = "tmp/.redshift_irb_shell_history"
+      else
+        conf[:HISTORY_FILE] = ".redshift_irb_shell_history"
+      end
+
+      IRB.setup nil
+      
+      at_exit do
+        IRB.irb_at_exit
+      end
+    end
+
+    workspace = IRB::WorkSpace.new(*args)
+
+    if conf[:SCRIPT] ## normally, set by parse_opts
+      @irb = IRB::Irb.new(workspace, conf[:SCRIPT])
+    else
+      @irb = IRB::Irb.new(workspace)
+    end
+
+    conf[:IRB_RC].call(@irb.context) if conf[:IRB_RC]
+    conf[:MAIN_CONTEXT] = @irb.context
+  end
+  
+  def run
+    @interrupt_requests = nil
+
+    trap("INT") do
+      @irb.signal_handle
+    end
+
+    begin
+      catch(:IRB_EXIT) do
+        @irb.eval_input
+      end
+    ensure
+      install_interrupt_handler
+    end
+  end
+    
+  def install_interrupt_handler
+    unless @interrupt_requests
+      @interrupt_requests = 0
+      trap("INT") do
+        @interrupt_requests += 1
+        if @interrupt_requests == 2
+          puts "\nType one more ^C to abort, or wait for RedShift shell."
+        elsif @interrupt_requests >= 3
+          exit!
+        end
+      end
+    end
+  end
+
+  def handle_interrupt after = nil
+    if @interrupt_requests && @interrupt_requests > 0
+      yield if block_given?
+      run
+      true
+    else
+      false
+    end
+  end
+end
+
+# extend a World instance with this (or include in a World subclass)
+module RedShift::Shellable
+  def shell
+    @shell ||= RedShift::IRBShell.new(binding, self)
+  end
+  
+  def run(*)
+    shell.install_interrupt_handler
+    super
+  end
+
+  def step(*)
+    super do
+      yield self if block_given?
+      if shell.handle_interrupt {before_shell}
+        after_shell
+        return
+      end
+    end
+  end
+  
+  # Override to complete some action before dropping into shell.
+  def before_shell
+  end
+  
+  # Override to complete some action after leaving shell.
+  def after_shell
+  end
+  
+  # Typically, call this in a rescue clause, if you to let the user
+  # examine state and possibly continue:
+  #
+  #   rescue ... => e
+  #     require 'redshift/mixins/irb-shell'
+  #     world.extend RedShift::IRBShell
+  #     world.recoverable_error e, "Assertion failure", e.backtrace
+  #
+  def recoverable_error e, msg = "Error", bt = []
+    puts "#{msg} at time #{clock}"
+    puts "From " + bt[0..2].join("\n     ") unless bt.empty
+    puts "     ..." if bt.length > 3
+    shell.run
+  end
+
+private
+  def q
+    exit
+  end
+
+  ## commands:
+  ##  step [n] {block}
+  ##  step_until/while
+  ##  continue -- safer than ^D, does step_discrete in case of changes
+  ##  step_continuous
+  ##  step_discrete [n]
+  ##  break [class/component/transition/comp.event/condition]
+  ##    until step_until, stops inside step_discrete
+  ##  clear
+  ##
+  ## customize prompt
+end

data/lib/redshift/redshift.rb

@@ -33,7 +33,7 @@ end
 module RedShift
   include Math
   
-  VERSION = '1.3.16'
+  VERSION = '1.3.17'
 
   Infinity = Math::Infinity
 

data/lib/redshift/syntax.rb

@@ -211,7 +211,11 @@ module FlowSyntax
     
     def initialize block
       @flows = []
-      instance_eval(&block)
+      val = instance_eval(&block)
+      if val.kind_of? String and val =~ /=/
+        warn "Equation appears to be missing a specifier (alg, diff, etc.):" +
+          val
+      end
     end
     
     def algebraic(*equations)
@@ -224,7 +228,7 @@ module FlowSyntax
     end
     
     def euler(*equations)
-      for equation in equations
+      equations.each do |equation|
         unless equation =~ /^\s*(\w+)\s*'\s*=\s*(.+)/m
           raise SyntaxError, "parse error in\n\t#{equation}."
         end
@@ -233,7 +237,7 @@ module FlowSyntax
     end
     
     def rk4(*equations)
-      for equation in equations
+      equations.each do |equation|
         unless equation =~ /^\s*(\w+)\s*'\s*=\s*(.+)/m
           raise SyntaxError, "parse error in\n\t#{equation}."
         end
@@ -252,7 +256,7 @@ module FlowSyntax
         ## rename 'feedback'?
       end
       feedback = opts[:feedback]
-      for equation in equations
+      equations.each do |equation|
         unless equation =~ /^\s*(\w+)\s*=\s*(.+)'\s*\z/m
           raise SyntaxError, "parse error in\n\t#{equation}."
         end

data/lib/redshift/target/c/flow/buffer.rb

@@ -8,10 +8,72 @@ class RedShift::Library
     include_file.declare :Buffer => %{
       typedef struct {
         long    len;
+        long    offset;
         double  *ptr;
       } Buffer;
     }.tabto(0)
 
+    source_file.define_c_function(:buffer_init).instance_eval {
+      arguments "Buffer *buf", "long len", "double fill"
+      scope :extern
+      body %{
+        int i;
+        buf->ptr = ALLOC_N(double, len);
+        buf->len = len;
+        buf->offset = 0;
+        for (i=0; i<len; i++) {
+          buf->ptr[i] = fill;
+        }
+      }
+    }
+    
+    source_file.define_c_function(:buffer_resize).instance_eval {
+      arguments "Buffer *buf", "long len"
+      scope :extern
+      body %{
+        long    i;
+        long    old_len = buf->len;
+        long    offset  = buf->offset;
+        double *ptr     = buf->ptr;
+        double *dst, *src;
+        double  fill;
+
+        if (len < old_len) {
+          if (offset < len) {
+            dst = ptr + offset;
+            src = ptr + offset + old_len - len;
+            memmove(dst, src, (len - offset) * sizeof(double));
+          }
+          else {
+            dst = ptr;
+            src = ptr + offset - len;
+            offset = 0;
+            memmove(dst, src, len * sizeof(double));
+          }
+          REALLOC_N(ptr, double, len);
+          // ## maybe better: don't release space, just use less of it
+        }
+        else if (len > old_len) {
+          REALLOC_N(ptr, double, len);
+
+          fill = ptr[offset];
+          dst = ptr + offset + len - old_len;
+          src = ptr + offset;
+          memmove(dst, src, (old_len - offset) * sizeof(double));
+
+          for (i = 0; i < len - old_len; i++) {
+            ptr[offset + i] = fill;
+          }
+        }
+        else
+          return;
+
+        buf->len = len;
+        buf->offset = offset;
+        buf->ptr = ptr;
+      }
+    }
+    
     source_file.define_c_function(:buffer_inhale_array).instance_eval {
       arguments "Buffer *buf", "VALUE ary"
       scope :extern
@@ -28,6 +90,7 @@ class RedShift::Library
           buf->ptr = ALLOC_N(double, size);
         }
         buf->len = size;
+        buf->offset = 0;
 
         for (i = 0; i < size; i++) {
           buf->ptr[i] = NUM2DBL(RARRAY(ary)->ptr[i]);
@@ -42,13 +105,17 @@ class RedShift::Library
       scope :extern
       declare :size => "int size",
               :i => "int i",
+              :j => "int j",
               :ary => "VALUE ary"
       body %{
         size = buf->len;
         ary = rb_ary_new2(size);
         RARRAY(ary)->len = size;
-        for (i = 0; i < size; i++) {
-          RARRAY(ary)->ptr[i] = rb_float_new(buf->ptr[i]);
+        for (i = buf->offset, j=0; i < size; i++, j++) {
+          RARRAY(ary)->ptr[j] = rb_float_new(buf->ptr[i]);
+        }
+        for (i = 0; i < buf->offset; i++, j++) {
+          RARRAY(ary)->ptr[j] = rb_float_new(buf->ptr[i]);
         }
       }
     }

data/lib/redshift/target/c/flow/delay.rb

@@ -17,13 +17,11 @@ module RedShift; class DelayFlow
       RedShift.library.define_buffer
 
       bufname     = "#{var_name}_buffer_data"
-      offsetname  = "#{var_name}_buffer_offset"
       delayname   = "#{var_name}_delay"
       tsname      = "#{var_name}_time_step"
       
       cl.class_eval do
         shadow_attr_accessor bufname    => "Buffer  #{bufname}"
-        shadow_attr_accessor offsetname => "long    #{offsetname}"
         shadow_attr_accessor delayname  => "double  #{delayname}"
           # delay should be set only using the expr designated in :by => "expr"
         shadow_attr          tsname     => "double  #{tsname}"
@@ -50,7 +48,7 @@ module RedShift; class DelayFlow
           
           ContVar   *var;
           double    *ptr;
-          long      i, len, offset, steps;
+          long      len, offset, steps;
           double    delay, fill;
         }
         setup :shadow => %{
@@ -77,7 +75,7 @@ module RedShift; class DelayFlow
           switch (shadow->world->rk_level) {
           case 0:
             ptr = shadow->#{bufname}.ptr;
-            offset = shadow->#{offsetname};
+            offset = shadow->#{bufname}.offset;
             
             if (shadow->world->time_step != shadow->#{tsname}) {
               if (shadow->#{tsname} == 0.0)
@@ -106,57 +104,17 @@ module RedShift; class DelayFlow
                 #{flow.translate(self, "fill", 0, cl).join("
                 ")};
 
-                ptr = ALLOC_N(double, len);
-                shadow->#{bufname}.ptr = ptr;
-                shadow->#{bufname}.len = len;
-                shadow->#{offsetname} = 0;
-                shadow->#{delayname} = delay;
-
-                for (i=0; i<len; i++) {
-                  ptr[i] = fill;
-                }
+                buffer_init(&shadow->#{bufname}, len, fill);
               }
               else { // # delay != shadow->#{delayname}
-                long old_len = shadow->#{bufname}.len;
-                double *dst, *src;
-
-                if (delay < shadow->#{delayname}) {
-                  if (offset < len) {
-                    dst = ptr + offset;
-                    src = ptr + offset + old_len - len;
-                  }
-                  else {
-                    dst = ptr;
-                    src = ptr + offset - len;
-                    offset = 0;
-                  }
-                  memmove(dst, src, (len - offset) * sizeof(double));
-                  REALLOC_N(ptr, double, len);
-                  // ## maybe better: don't release space, just use less of it
-                }
-                else { // # delay > shadow->#{delayname}
-                  REALLOC_N(ptr, double, len);
-
-                  fill = ptr[offset];
-                  dst = ptr + offset + len - old_len;
-                  src = ptr + offset;
-                  memmove(dst, src, (old_len - offset) * sizeof(double));
-
-                  for (i = 0; i < len - old_len; i++) {
-                    ptr[offset + i] = fill;
-                  }
-                }
-                
-                shadow->#{bufname}.ptr = ptr;
-                shadow->#{bufname}.len = len;
-                shadow->#{offsetname} = offset;
-                shadow->#{delayname} = delay;
+                buffer_resize(&shadow->#{bufname}, len);
               }
+              
+              shadow->#{delayname} = delay;
+              ptr = shadow->#{bufname}.ptr;
+              offset = shadow->#{bufname}.offset;
             }
             
-            offset = (offset + 4) % len;
-            shadow->#{offsetname} = offset;
-            
             var->value_0 = ptr[offset];
             var->value_1 = ptr[offset + 1];
             var->value_2 = ptr[offset + 2];
@@ -173,7 +131,7 @@ module RedShift; class DelayFlow
           case 3:
             ptr = shadow->#{bufname}.ptr;
             len = shadow->#{bufname}.len;
-            offset = shadow->#{offsetname};
+            offset = shadow->#{bufname}.offset;
 
             #{flow.translate(self, "ptr[offset+1]", 1, cl).join("
             ")};
@@ -182,7 +140,9 @@ module RedShift; class DelayFlow
             #{flow.translate(self, "ptr[offset+3]", 3, cl).join("
             ")};
 
-            var->value_0 = ptr[(offset + 4) % len];
+            offset = (offset + 4) % len;
+            var->value_0 = ptr[offset];
+            shadow->#{bufname}.offset = offset;
             break;
             
           default:

data/lib/redshift/util/tkar-driver.rb

@@ -0,0 +1,93 @@
+# Manages interface to external animation process.
+# Depends on:
+#   gem install tkar
+# See also:
+#   http://tkar.rubyforge.org
+class TkarDriver
+  # +dragger+ is a callable object that takes (id, x, y) and should
+  # move object id to (x,y)
+  def initialize dragger
+    @dragger = dragger
+    cmd =
+      case RUBY_PLATFORM
+      when /mswin/
+        "tkar --radians 2>nul"
+      else
+        # Use setsid so that ^C doesn't kill it
+        "setsid tkar --radians 2>/dev/null"
+      end
+
+    @pipe = IO.popen(cmd, "w+")
+    yield @pipe if block_given?
+
+    @buf = 0
+    update
+  end
+
+  # never let the simulation get more than this many steps ahead
+  MAX_LAG = 10
+  
+  # let the visualization lag by this many steps, or more
+  MIN_LAG = 5
+
+  def close
+    if @pipe
+      @pipe.close
+      @pipe = nil
+    end
+  end
+  
+  def closed?
+    return true if not @pipe or @pipe.closed?
+    
+    begin
+      @pipe.puts " " # no-op
+      @pipe.flush
+    rescue Errno::EPIPE
+      close
+      true
+    else
+      @pipe.closed?
+    end
+  end
+
+  # :yields: pipe
+  def update
+    return unless @pipe
+
+    yield @pipe if block_given?
+
+    @pipe.puts "update"
+    @pipe.flush
+    @buf += 1
+    if @buf > MAX_LAG
+      catch_up_within MIN_LAG
+    end
+  rescue Errno::EPIPE
+    close
+  end
+
+  def catch_up_within steps
+    return unless @pipe
+
+    while @buf > steps || (steps==0 && select([@pipe],[],[],0))
+        ## alternately: if steps==0, send "echo ..." and wait for ...
+      case line=@pipe.gets
+      when nil
+        close
+        return
+      when /^update$/
+        @buf -= 1
+      when /^drag (\S+) (\S+) (\S+)/
+        drag_parms = $1.to_i, $2.to_f, $3.to_f
+      when /^drop/
+        @dragger[*drag_parms] if @dragger
+      ## TODO: handle dropping on another object
+      else
+        puts "tkar: #{line}"
+      end
+    end
+  rescue Errno::EPIPE
+    close
+  end
+end

data/lib/redshift/world.rb

@@ -38,7 +38,7 @@ class World
     end
     
     def [](idx)
-      warn "World#[] is deprecated"
+      warn "#{self.class}#[] is deprecated"
       to_a[idx] ## very inefficient
     end
     

data/rakefile

@@ -31,6 +31,8 @@ END
   test.files = Dir["test/test_*.rb"]
 }
 
+task 'gem:release' => 'rubyforge:release' # to release to rubyforge as well
+
 task :release => ["rubyforge:release", "rubyforge:doc_release"]
 
 # EOF

data/test/test_delay.rb

@@ -142,4 +142,6 @@ class TestDelay < Test::Unit::TestCase
       #puts "%5.3f: %5.3f" % [c.x, c.xd]
     end
   end
+  
+  ## TODO: test variable delay
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: redshift
 version: !ruby/object:Gem::Version 
-  hash: 59
+  hash: 57
   prerelease: false
   segments: 
   - 1
   - 3
-  - 16
-  version: 1.3.16
+  - 17
+  version: 1.3.17
 platform: ruby
 authors: 
 - Joel VanderWerf
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-06 00:00:00 -07:00
+date: 2010-06-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,12 +40,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 17
+        hash: 27
         segments: 
         - 3
         - 4
-        - 3
-        version: 3.4.3
+        - 6
+        version: 3.4.6
   type: :development
   version_requirements: *id002
 description: |
@@ -96,6 +96,7 @@ files:
 - examples/reset-with-event-val.rb
 - examples/scheduler.rb
 - examples/set-dest.rb
+- examples/shell.rb
 - examples/simulink/README
 - examples/simulink/delay.mdl
 - examples/simulink/derivative.mdl
@@ -110,6 +111,7 @@ files:
 - lib/redshift.rb
 - lib/redshift/component.rb
 - lib/redshift/meta.rb
+- lib/redshift/mixins/irb-shell.rb
 - lib/redshift/mixins/zeno-debugger.rb
 - lib/redshift/port.rb
 - lib/redshift/queue.rb
@@ -136,6 +138,7 @@ files:
 - lib/redshift/util/plot.rb
 - lib/redshift/util/random.rb
 - lib/redshift/util/superhash.rb
+- lib/redshift/util/tkar-driver.rb
 - lib/redshift/util/tracer.rb
 - lib/redshift/util/tracer/trace.rb
 - lib/redshift/util/tracer/var.rb