redshift 1.3.15

data/examples/step-discrete-profiler.rb

@@ -0,0 +1,103 @@
+require 'redshift'
+
+include RedShift
+
+# This example is a simple profiler for measuring time in guard phases and
+# proc/reset phases. Finer grained measurements can be done using other hooks.
+
+# See examples/step-discrete-hook.rb for more examples of hook methods.
+
+# Note that ruby's profiler.rb can be used to profile the ruby methods, it just
+# doesn't give any results _within_ World#step_discrete.
+
+n_components = 1000
+n_seconds = 1000
+
+class ProfilingExample < Component
+  continuous :x
+  
+  def x_less_than_0
+    x < 0
+  end
+  
+  def reset_x
+    self.x = 2
+  end
+  
+  transition do
+#    guard :x_less_than_0  # 36.1 ms
+#    guard {x < 0}         # 61.0 ms
+    guard "x < 0"         #  3.2 ms
+
+#    action :reset_x       #  1.8 ms
+#    action {self.x = 2}   #  4.5 ms
+    
+    reset :x => 2         #  1.3 ms
+  end
+  flow { diff "x' = -1" }
+end
+
+class ProfilingWorld < World
+  attr_accessor :guard_time, :proc_time, :reset_time
+  
+  def cpu_time
+    #Time.now
+    Process.times.utime # for short runs, this doesn't have enough granularity
+  end
+  
+  def initialize(*args)
+    super
+    @guard_time = 0
+    @proc_time = 0
+    @reset_time = 0
+  end
+  
+  def hook_enter_guard_phase
+    @guard_start = cpu_time
+  end
+
+  def hook_leave_guard_phase
+    t = cpu_time
+    @guard_time += t - @guard_start
+  end
+  
+  def hook_enter_action_phase
+    @proc_start = cpu_time
+  end
+  
+  def hook_leave_action_phase
+    t = cpu_time
+    @proc_time += t - @proc_start
+  end
+  
+  def hook_begin_eval_resets(comp)
+    @reset_start = cpu_time
+  end
+  
+  def hook_end_eval_resets(comp)
+    t = cpu_time
+    @reset_time += cpu_time - @reset_start
+  end
+  
+  def hook_begin_parallel_assign
+    @reset_start = cpu_time
+  end
+  
+  def hook_end_parallel_assign
+    t = cpu_time
+    @reset_time += cpu_time - @reset_start
+  end
+end
+
+w = ProfilingWorld.new
+n_components.times do
+  w.create(ProfilingExample)
+end
+
+w.evolve n_seconds
+
+x = n_components * n_seconds
+puts "Times are averages per component, per second of simulation."
+printf "Guard time: %10.3f ms\n", (w.guard_time/x)*1_000_000
+printf "Proc time:  %10.3f ms\n", (w.proc_time/x)*1_000_000
+printf "Reset time: %10.3f ms\n", (w.reset_time/x)*1_000_000

data/examples/subsystem.rb

@@ -0,0 +1,109 @@
+# Shows how to use subsystems in redshift like in simulink.
+
+require 'redshift'
+include RedShift
+
+# First, let's define some "blocks" to put inside the subsystem.
+
+# A generic integrator block.
+class Integrator < Component
+  input :dx_dt
+  flow { diff " x' = dx_dt " }
+end
+
+# A specific algebraic equation.
+class Alg < Component
+  input :in
+  flow { alg " out = pow(in, 2) - 6 * in - 10 " }
+end
+
+# Now, the subsystem container:
+class Subsystem < Component
+  input :in
+  input :out  # declared as input because it is input from subcomponent
+end
+
+# We need a data source, so let's just use a linear input:
+class Timer < Component
+  flow { diff " time' = 1 " }
+end
+
+# A component to check results by solving analytically:
+class Checker < Component
+  input :in
+  constant :c # for integration constant
+  flow { alg " true_result = pow(in, 3)/3 - 3 * pow(in, 2) - 10 * in + c " }
+    # symbolically integrated
+end
+
+# In practice, the subsystem, with the sub-blocks and connections created below,
+# could be coded in much simpler way in redshift, by combining the differential
+# and algebraic equations and even the timer. Sometimes, however, input ports
+# are a convenient way to reuse functionality. They have the advantage over link
+# variables of not needing to know the class of the source component, so it's
+# possible to have independent libraries of them.
+class MuchSimpler < Component
+  flow {
+    diff " t' = 1 "
+    diff " x' = pow(t, 2) - 6 * t - 10 "
+  }
+end
+
+# Enough definitions. Now, before we can run anything, we need to construct
+# instances of these classes in a world.
+world = World.new
+
+# Create the subsystem and its sub-blocks.
+subsystem = world.create Subsystem do |sys|
+  # create the sub-blocks (note that the vars are local, so the 
+  # sub-blocks are encapsulated at the syntactic level):
+  int = world.create(Integrator)
+  alg = world.create(Alg)
+  
+  # specify an initial condition
+  int.x = 200
+  
+  # wire everything together
+  sys.port(:in) >> alg.port(:in)
+  alg.port(:out) >> int.port(:dx_dt)
+  int.port(:x) >> sys.port(:out)
+end
+
+# Create the data source and connect to the subsystem:
+timer = world.create(Timer)
+timer.time = 0
+timer.port(:time) >> subsystem.port(:in)
+
+# Create the checker and connect to timer:
+checker = world.create(Checker)
+checker.port(:in) << timer.port(:time)
+checker.c = subsystem.out # must agree on initial condition
+
+# Compare with a single-component implementation.
+much_simpler = world.create(MuchSimpler)
+much_simpler.x = subsystem.out # must agree in initial condition
+
+result = []; error = []; error2 = []
+gather = proc do
+  result << [timer.time, subsystem.out]
+  error  << [timer.time, subsystem.out - checker.true_result]
+  error2 << [timer.time, subsystem.out - much_simpler.x]
+end
+
+gather.call
+world.evolve 20 do
+  gather.call
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Subsystem"}
+  plot.command %{set xlabel "time"}
+  plot.add result, %{title "subsystem f(t)" with lines}
+  plot.add error, %{title "error in f(t)" with lines}
+  plot.add error2, %{title "error2 in f(t)" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM

data/examples/sync-deadlock.rb

@@ -0,0 +1,32 @@
+# Shows how not all combinations of transitions are
+# checked, because to do so would invite indeterminate
+# behavior, and require exponential cpu.
+#
+# The first transition in c1 could sync with the second
+# in c2, or the second in c2 with the first in c1. The
+# problem is that neither of these pairs can be chosen in a
+# natural way, so neither gets chosen.
+
+require 'redshift'
+
+class C < RedShift::Component
+  link :other
+  transition Enter => Exit do
+    sync :other => :e
+    event :f
+  end
+  transition Enter => Exit do
+    sync :other => :f
+    event :e
+  end
+end
+
+w = RedShift::World.new
+c1 = w.create C
+c2 = w.create C
+c1.other = c2
+c2.other = c1
+
+w.run 1
+p c1
+p c2

data/examples/sync-queue.rb

@@ -0,0 +1,91 @@
+# A more complex example of the sync construct:
+# clients make a request to a server (using a queue)
+# the server syncs with the head of the queue, and
+# provides the requested information.
+#
+# This shows the use of bi-directional sync, as well as
+# using a guard to ensure that only the proper client can
+# sync.
+
+require 'redshift'
+
+class Client < RedShift::Component
+  state :Working, :Waiting
+  start Working
+  
+  link :server
+  
+  flow Working do
+    diff " time_left' = -1 "
+  end
+    
+  transition Working => Waiting do
+    guard "time_left <= 0"
+    action do
+      if server
+        puts "%4.2f: #{self} requesting service" % world.clock
+        server.clients << self
+      end
+    end
+  end
+  
+  transition Waiting => Working do
+    guard {server.client == self} # N.b.!
+    sync :server => :serve
+    event :accept
+    post do
+      self.time_left = server.serve # can do this as reset
+      puts "%4.2f: #{self} receiving service, time_left=#{time_left}" %
+        world.clock
+    end
+  end
+end
+
+class Server < RedShift::Component
+  state :Waiting, :Serving
+  start Waiting
+  
+  # the client currently being served
+  link :client
+  
+  queue :clients
+  
+  transition Waiting => Serving do
+    wait :clients
+    action do
+      cs = clients.pop
+      case cs
+      when RedShift::SimultaneousQueueEntries
+        self.client = cs.shift # NOT deterministic--should rank clients
+        clients.unpop cs # put the rest back on the head of the queue
+      when RedShift::Component
+        self.client = cs
+      else
+        raise "Error!"
+      end
+    end
+  end
+  
+  transition Serving => Waiting do
+    guard {client.server == self} # N.b.!
+    sync :client => :accept
+    event :serve => proc {1.0 + rand()}
+    action do
+      puts "%4.2f: #{self} serving #{client}" % world.clock
+      self.client = nil
+    end
+  end
+end
+
+srand 54321
+
+w = RedShift::World.new
+s = w.create(Server)
+10.times do
+  w.create Client do |c|
+    c.server = s
+  end
+end
+
+w.evolve 10.0
+

data/examples/sync-retry.rb

@@ -0,0 +1,20 @@
+require 'redshift'
+
+class Sync < RedShift::Component
+  link :next
+  setup {self.next = nil} # or a comp that doesn't emit :no_such_event
+  transition Enter => Exit do
+    # this transition is checked first, but can't sync
+    sync :next => :no_such_event
+  end
+  transition Enter => Exit do
+    # so this trans is checked second
+    action do
+      puts "else (if no sync), take this transition"
+    end
+  end
+end
+
+w = RedShift::World.new
+w.create(Sync)
+w.run 1

data/examples/sync.rb

@@ -0,0 +1,51 @@
+# Example of the sync construct: synchronizing transitions
+# in two or more components.
+#
+# This is an example of unidirectional sync: component a takes
+# its transition without requiring sync (it has a guard, but the
+# guard only looks at the current state of the world, not at who
+# else might emit some event), while b takes its transition
+# _only_ if it can sync with a on the event e.
+#
+# See sync-queue.rb for a bi-directional example.
+
+require 'redshift'
+
+class A < RedShift::Component
+  state :A1, :A2
+  start A1
+  
+  flow A1 do
+    diff " t' = 1 "
+  end
+  
+  transition A1 => A2 do
+    guard "t > 0.5"
+    event :e
+    action do
+      puts "#{self} taking transition #{self.state} => #{self.dest}" +
+           " at time #{world.clock}"
+    end
+  end
+end
+
+class B < RedShift::Component
+  state :B1, :B2
+  start B1
+  
+  link :a
+  
+  transition B1 => B2 do
+    sync :a => :e # remove this line to see the difference
+    action do
+      puts "#{self} taking transition #{self.state} => #{self.dest}" +
+           " at time #{world.clock}"
+    end
+  end
+end
+
+w = RedShift::World.new
+b = w.create(B)
+b.a = w.create(A)
+
+w.evolve 1.0

data/examples/thermostat.rb

@@ -0,0 +1,53 @@
+require 'redshift'
+
+class Thermostat < RedShift::Component
+  continuous :temp
+  
+  state :Heat, :Off
+
+  flow Heat do
+    diff "temp' = (68 - temp)/3"
+  end
+
+  flow Off do
+    diff "temp' = (45 - temp)/10"
+  end
+  
+  transition Heat => Off do
+    guard "temp > 68 - 0.1"
+  end
+  
+  transition Off => Heat do
+    guard "temp < 66"
+  end
+  
+  setup do
+    start Off
+  end
+end
+
+world = RedShift::World.new do |w|
+  w.time_step = 0.1
+end
+
+thermostat = world.create Thermostat do |t|
+  t.temp = 55
+end
+
+temp_history = []
+world.evolve 30 do |w|
+  point = [w.clock, thermostat.temp]
+  #puts point.join(" ")
+  temp_history << point
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Thermostat control"}
+  plot.command %{set xlabel "time"}
+  plot.add temp_history, %{title "temperature" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM