redshift 1.3.15

data/examples/ball.rb

@@ -0,0 +1,123 @@
+require 'redshift'
+
+include RedShift
+
+class Observer < Component
+  link :ball => :Ball
+  state :Observing, :Decision
+  attr_reader :counter
+
+  setup do
+    @counter = 0
+  end
+  
+  start Observing
+
+  transition Observing => Decision do
+    sync :ball => :impact
+    action do
+      print "\n\n ***** Time of impact #{world.clock}.\n\n"
+      @counter += 1
+    end
+  end
+  
+  transition Decision => Exit do
+    guard {@counter == 2}
+    action {print " ***** Observer leaving after 2 bounces.\n\n"}
+  end
+  
+  transition Decision => Observing do
+    guard {@counter < 2}
+  end
+end
+
+class Ball < Component
+  constant :y0, :v0, :a, :bounce_count
+  state :Falling, :Rising
+  
+  flow Falling, Rising do
+    differential  " y' = v "
+    euler         " v' = a "
+    
+    euler         " t_elapsed' = 1.0 "
+    algebraic     " true_y = y0 + v0 * t_elapsed +
+                             0.5 * a * pow(t_elapsed, 2) "
+    algebraic     " y_err = fabs(true_y - y) "
+  end
+  
+  transition Falling => Rising do
+    guard "y <= 0"
+    event :impact
+    reset :v  => "-v",
+          :y0 => "y",
+          :v0 => "-v",
+          :t_elapsed => 0,
+          :bounce_count => "bounce_count + 1"
+    # The reset is essentially the same as:
+    # action {
+    #   self.v = -v
+    #   self.y0 = y; self.v0 = v
+    #   self.t_elapsed = 0.0
+    #   self.bounce_count += 1
+    # }
+    # The difference: reset is faster, and has parallel semantics,
+    # which is why ':v0 => "-v"', in place of 'self.v0 = v'.
+  end
+  
+  transition Rising => Falling do
+    guard "v <= 0"
+  end
+  
+  transition Rising => Exit, Falling => Exit do
+    guard "bounce_count >= 3"
+  end
+  
+  defaults {
+    start Falling
+    self.y0 = 100.0
+    self.v0 = 0.0
+    self.a = -9.8
+  }
+  
+  setup {
+    self.y = y0; self.v = v0
+    self.t_elapsed = 0.0
+    self.bounce_count = 0
+  }
+  
+  def inspect
+    sprintf "y = %8.4f, v = %8.4f, y_err = %8.6f%16s",
+            y, v, y_err, state
+  end
+end
+
+w = World.new
+w.time_step = 0.01
+
+ball = w.create(Ball) {|b| b.a = -9.8}
+w.create(Observer) {|o|o.ball = ball}
+
+y = [[w.clock, ball.y]]
+
+while w.size > 0 do
+  t = w.clock
+  if t == t.floor
+    print "\nTime #{t}\n"
+  end
+  p ball unless ball.state == Exit
+  
+  w.run
+  
+  y << [w.clock, ball.y]
+end
+
+if ARGV.delete('-p')
+  require 'sci/plot'
+  include Plot::PlotUtils
+
+  gnuplot do |plot|
+    plot.add y, 'title "height" with lines'
+  end
+else
+  puts "use -p switch to show plot"
+end

data/examples/collide.rb

@@ -0,0 +1,70 @@
+# Example of using sync and events to exchange data in parallel. This assumes that
+# the two components are already linked, so it doesn't scale well. A scalable
+# solution would separate detection into a cell mechanism or something, and use
+# queues to notify the components. This example is more about collision _handling_
+# than _detection_.
+
+require 'redshift'
+
+class Ball < RedShift::Component
+  link :other => Ball
+  continuous :v
+  constant :dir
+  
+  state :Moving
+  
+  transition Enter => Moving do
+    action do
+      self.dir = other.x < x ? -1 : 1
+    end
+  end
+  
+  flow Moving do
+    diff " x' = v "
+  end
+  
+  transition Moving => Moving do
+    guard " dir * (other.x - x) < 0 "
+    guard {other.other == self}
+      # meaning: only if other is colliding with self
+      # The guard above is a bit unnecessary in this model,
+      # but in general it is needed.
+    sync :other => :collision
+    event :collision
+    reset :v => "other.v", :x => "other.x"
+  end
+end
+
+w = RedShift::World.new
+b1 = w.create Ball
+b2 = w.create Ball
+b1.other = b2
+b2.other = b1
+b1.x =   0.0
+b1.v =  30.0
+b2.x = 100.0
+b2.v = -70.0
+
+b1_x, b2_x = [], []
+gather = proc do
+  time = w.clock
+  b1_x << [time, b1.x]
+  b2_x << [time, b2.x]
+end
+
+gather.call
+w.evolve 1.2 do
+  gather.call
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Bouncing balls"}
+  plot.command %{set xlabel "time"}
+  plot.add b1_x, %{title "b1.x" with lines}
+  plot.add b2_x, %{title "b2.x" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM

data/examples/connect-parallel.rb

@@ -0,0 +1,48 @@
+# Shows how to connect input variables in parallel, and also in
+# parallel with resets.
+
+require "redshift"
+include RedShift
+
+class A < Component
+  input :in
+  continuous :x => 1
+  constant :k => 1
+  link :comp
+  
+  state :T
+  
+  flow T do
+    diff " x' = k*in "
+  end
+  
+  transition Enter => T do
+    reset :comp => nil # in parallel with the connect
+    if true
+      connect :in => proc {comp.port(:x)}
+# alternate syntaxes:
+#      connect port(:in).to {comp.port(:x)}
+#      port(:in).connect {comp.port(:x)}
+#      connect { in {comp.port :x}; ... }
+    else
+      connect :in => [:comp, :x] # special case: literals
+    end
+    
+    # The non-parallel equivalent, which would fail after
+    # resetting comp to nil:
+    #
+    # action do
+    #   port(:in) << comp.port(:x)
+    # end
+    ## actually this would fail as a post, but not as action
+  end
+end
+
+w = World.new
+w.time_step = 0.001
+a0, a1 = (0..1).map {w.create(A)}
+a0.comp = a1
+a1.comp = a0
+
+w.evolve 1
+p a0, a1

data/examples/connect.rb

@@ -0,0 +1,109 @@
+require "redshift"
+include RedShift
+
+class A < Component
+  continuous :x
+  constant :k => 6.78
+  flow do
+    diff " x' = 2*x "
+  end
+end
+
+class B < Component
+  input :y
+end
+
+world = World.new
+
+a = world.create(A)
+b = world.create(B)
+
+begin
+  b.y
+rescue RedShift::UnconnectedInputError => ex
+  puts "As expected: #{ex}"
+end
+
+b.connect(:y, a, :x)
+  # doesn't construct Port objects, so slightly more efficent
+p(b.port(:y) << a.port(:x)) # Port#<< is alias for Port#connect
+
+begin
+  a.port(:x) << b.port(:y)
+rescue TypeError => ex
+  puts "As expected: #{ex}"
+end
+
+begin
+  b.y = 1.23              # error
+rescue NoMethodError => ex
+  puts "As expected: #{ex}"
+end
+
+a.x = 4.56
+p b.y                     # ok
+p b
+
+p b.port(:y).source == a.port(:x) # true
+p b.port(:y).source_component     # a
+p b.port(:y).source_variable      # :x
+
+p a.port(:x).component    # a
+p a.port(:x).variable     # :x
+
+b.disconnect :y
+b.port(:y).disconnect   # same
+b.port(:y) << nil       # same
+
+begin
+  b.y
+rescue RedShift::UnconnectedInputError => ex
+  puts "As expected: #{ex}"
+end
+
+p A.offset_table
+p B.offset_table
+
+b.port(:y) << a.port(:x)
+world.evolve 1 do
+  p [a.x, b.y]
+end
+
+b.port(:y) << a.port(:k) # reconnect, but this time to a constant
+world.evolve 0.5 do
+  p [a.k, b.y]
+end
+
+puts <<END
+
+  This example shows four things:
+  
+  1. you can connect an input to an input (b1 to b2, and b2 to b3).
+  2. >> as an alternative to <<
+  3. chaining >> (or <<)
+  4. two input ports connected to the same var (b1 and b4 conn to a)
+  
+END
+
+b1 = world.create(B)
+b2 = world.create(B)
+b3 = world.create(B)
+b4 = world.create(B)
+
+a.port(:x) >> b4.port(:y)
+a.port(:x) >> b1.port(:y) >> b2.port(:y) >> b3.port(:y)
+
+a.x = 3
+p b3.y
+
+puts <<END
+
+  This example shows that connections are treated dynamically, not statically.
+  Changing an upstream connection during a run affects all downstream vars.
+  
+END
+
+a2 = world.create(A)
+a2.x = 4
+a2.port(:x) >> b1.port(:y)
+p b2.y

data/examples/constants.rb

@@ -0,0 +1,27 @@
+# Overview of the different kinds of "constants" in redshift.
+#
+# 1. constants defined in a ruby module
+#
+# 2. constants defined in an external library -- see external-lib.rb
+#
+# 3. per component constant _functions_ (strict or piecewise).
+
+require 'redshift'
+
+RedShift.with_library do |library|
+  library.declare_external_constant "M_E" # GNU C math lib
+end
+
+class C < RedShift::Component
+  K = 10
+  L = 456
+  constant :kk => 2 # per instance, and can change discretely
+  
+  flow do
+    alg "x = kk*K + #{L*1000} + M_E"
+  end
+end
+
+w = RedShift::World.new
+c = w.create C
+p c.x

data/examples/delay.rb

@@ -0,0 +1,80 @@
+# Delay of a continuous signal by a given time.
+
+# Compare with simulink/delay.mdl -- note that redshift is more accurate
+# because the delay flow operates at all integrator steps, not just at
+# the simulation timesteps.
+
+require 'redshift'
+include RedShift
+
+class C < Component
+  constant :pi => Math::PI
+  constant :d => 0.3
+
+  state :A, :B
+  start A
+  
+  flow A, B do
+    diff   "       t' = 1 "
+    alg    "       u  = sin(t*pi/2) "
+    alg    " shift_u  = sin((t-d)*pi/2) " # u shifted by d
+    delay  " delay_u  = u ",  # delayed output from u (can be any expr)
+            :by => "d"        # delayed by d (can be any expr)
+    alg    "     err  = shift_u - delay_u "
+    
+    # Check how delay interacts with integration:
+    diff   "     idu' = delay_u "
+    diff   "      iu' = u"
+    delay  "     diu  = iu ", :by => "d"
+    alg    "iddi_err  = idu - diu"
+  end
+
+  constant :new_d => 0.5  # change this to see how varying delay works
+  constant :t_new_d => 5.0
+  transition A => B do
+    guard "t >= t_new_d"
+    reset :d => "new_d"
+  end
+  # Note that the buffered u values are preserved in the transition
+end
+
+world = World.new
+world.time_step = 0.1
+c = world.create(C)
+
+u, shift_u, delay_u, err, iddi_err = [], [], [], [], []
+gather = proc do
+  time = c.t
+  u       << [time, c.u]
+  shift_u << [time, c.shift_u]
+  delay_u << [time, c.delay_u]
+  err     << [time, c.err]
+  iddi_err<< [time, c.iddi_err]
+end
+
+gather.call
+world.evolve 10 do
+  gather.call
+end
+
+# The buffer used to store u's history is available:
+if false
+  p c.delay_u_buffer_data
+  p c.delay_u_buffer_offset
+  p c.delay_u_delay
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Time delay"}
+  plot.command %{set xlabel "time"}
+  plot.add u, %{title "u" with lines}
+  plot.add shift_u, %{title "shift_u" with lines}
+  plot.add delay_u, %{title "delay_u" with lines}
+  plot.add err, %{title "err" with lines}
+  plot.add iddi_err, %{title "iddi_err" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM