redshift 1.3.15

data/examples/derivative.rb

@@ -0,0 +1,77 @@
+# Numerical differentiation.
+
+# Compare with simulink/derivative.mdl -- note that redshift is more accurate
+# because the derivative flow operates at all integrator steps, not just at
+# the simulation timesteps.
+
+require 'redshift'
+include RedShift
+
+class C < Component
+  flow do
+    diff   "     t' = 1 "
+
+    alg    "     u  = sin(t) "
+    alg    "   sdu  = cos(t) " # symbolic derivative
+    derive "   ndu  = u'     ",# numerical derivative (can be (<expr>)' )
+            :feedback => false
+    diff   " nindu' = ndu    " # numerical integral of ndu
+    diff   "   niu' = u      " # numerical integral of u
+    derive " ndniu  = niu'   ",# numerical derivative of niu
+            :feedback => false
+    
+    alg    "   err  = sdu - ndu "
+      # This error is small.
+    
+    alg    " e_ndni = ndniu - u "
+    alg    " e_nind = nindu - u "
+      # The error is very small when numerically differentiating a signal that
+      # has been numerically integrated (e_ndni), but the error is worse
+      # for the integral of a differentiated signal (e_nind).
+  end
+
+#  Some alternative examples:
+#    alg    "     u  = pow(t, 4) - 17*pow(t,3) + 102*pow(t,2) - 1300*t "
+#    alg    "   sdu  = 4*pow(t, 3) - 3*17*pow(t,2) + 2*102*t - 1300 "
+#
+#  continuous :u => 1, :nindu => 1, :ndniu =>1
+#    diff   "    u'  = 0.02*u "
+#    alg    "   sdu  = 0.02*exp(0.02*u) "
+end
+
+world = World.new
+c = world.create(C)
+
+u, sdu, ndu, nindu, err, e_ndni, e_nind = [], [], [], [], [], [], []
+gather = proc do
+  time = c.t
+  u       << [time, c.u]
+  sdu     << [time, c.sdu]
+  ndu     << [time, c.ndu]
+  nindu   << [time, c.nindu]
+  err     << [time, c.err]
+  e_ndni  << [time, c.e_ndni]
+  e_nind  << [time, c.e_nind]
+end
+
+gather.call
+world.evolve 10 do
+  gather.call
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Numerical differentiation"}
+  plot.command %{set xlabel "time"}
+  plot.add u, %{title "u" with lines}
+  plot.add sdu, %{title "sdu" with lines}
+  plot.add ndu, %{title "ndu" with lines}
+  plot.add nindu, %{title "nindu" with lines}
+  plot.add err, %{title "err" with lines}
+  plot.add e_ndni, %{title "e_ndni" with lines}
+  plot.add e_nind, %{title "e_nind" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM

data/examples/euler.rb

@@ -0,0 +1,46 @@
+require 'redshift'
+
+include RedShift
+
+class Flow_Euler < Component
+  flow do
+    euler "x' = 1"
+    euler "y_euler' = x" # y is a worse approx of z, due to Euler
+    diff  "  y_rk4' = x"
+    alg   "  y_true = 0.5 * pow(x,2)" # the true value
+  end
+end
+
+world = World.new
+c = world.create(Flow_Euler)
+
+
+x, y_euler, y_rk4, y_true, rk4_err, euler_err = [], [], [], [], [], []
+gather = proc do
+  time = world.clock
+  x << [time, c.x]
+  y_euler << [time, c.y_euler]
+  y_rk4 << [time, c.y_rk4]
+  y_true << [time, c.y_true]
+  rk4_err << [time, (c.y_rk4 - c.y_true).abs]
+  euler_err << [time, (c.y_euler - c.y_true).abs]
+end
+
+gather.call
+world.evolve 10 do
+  gather.call
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Euler Integration"}
+  plot.command %{set xlabel "time"}
+  plot.add x, %{title "x" with lines}
+  plot.add y_true, %{title "y_true" with lp}
+  plot.add y_rk4, %{title "y_rk4" with lp}
+  plot.add y_euler, %{title "y_euler" with lp}
+  plot.add rk4_err, %{title "rk4_err" with lp}
+  plot.add euler_err, %{title "euler_err" with lp}
+end

data/examples/external-lib.rb

@@ -0,0 +1,33 @@
+# Example of using an external C lib with redshift. Note that
+# <math.h> is included and -lm is linked by default.
+
+require 'redshift'
+
+RedShift.with_library do |library|
+  library.include_file.include "<gsl/gsl_sf_gamma.h>"
+  library.include_file.include "<gsl/gsl_math.h>"
+  library.include_file.include "<gsl/gsl_const_mksa.h>"
+  library.link_with "-lgsl"
+  library.declare_external_constant "GSL_CONST_MKSA_MASS_ELECTRON"
+
+  # If you need custom cflags, you can put them here:
+  # $CFLAGS = "-fPIC -O2 -march=i686 -msse2 -mfpmath=sse"
+end
+
+class C < RedShift::Component
+  continuous :x, :y
+  
+  flow do
+    diff " y' = 2 + GSL_CONST_MKSA_MASS_ELECTRON "
+  end
+  
+  transition Enter => Exit do
+    guard " gsl_fcmp(y, 1.0, 0.01) == 0 "
+    reset :x => "gsl_sf_taylorcoeff(3, 2)"
+  end
+end
+
+w = RedShift::World.new
+c = w.create C
+w.evolve 1
+p c.x, c.y

data/examples/guard-debugger.rb

@@ -0,0 +1,77 @@
+require 'redshift'
+
+include RedShift
+
+# This example is a simple debugger for stepping through guards. It's not
+# intended to be useful as a debugger, but to show how hook methods can be
+# used to develop debuggers.
+#
+# See examples/step-discrete-hook.rb for more examples of hook methods.
+#
+# See mixins/debugger.rb and examples/debugger.rb for a more useful debugger.
+
+class DebuggingWorld < World
+  def hook_eval_guard(comp, guard, enabled, trans, dest)
+    puts "%-30p %-30p %-8s %6d" %
+         [comp, guard, enabled ? "enabled" : nil, discrete_step]
+    if enabled and dest != comp.state
+      puts "%-30s %-30s %-s" % [nil, nil, "#{comp.state} => #{dest}"]
+    end
+    puts "press <enter> to continue"
+    gets
+  end
+
+  def hook_begin
+    puts "-"*60
+    puts "Begin discrete update in #{inspect}"
+    puts "press <enter> to continue, ^C at any time to stop"
+    puts "%-30s %-30s %-8s %6s" %
+         %w(component guard status step)
+    gets
+  end
+
+  def hook_end
+    puts "End discrete update in #{inspect}"
+    puts "press <enter> to continue"
+    gets
+  end
+end
+
+class Thing < Component
+  state :A, :B
+  start A
+  
+  continuous :x
+  flow A do
+    diff "x' = 1"
+  end
+  
+  transition A => B do
+    guard "x > 2"
+  end
+  
+  transition B => A do
+    guard "x < 1e-10"
+    reset :x => 0
+  end
+  
+  transition B => B do
+    guard "x >= 1e-10"
+    reset :x => "x-1"
+  end
+end
+
+w = DebuggingWorld.new
+
+w.create(Thing) do |th|
+  th.name = 1
+  th.x = 0.5
+end
+
+w.create(Thing) do |th|
+  th.name = 2
+  th.x = 5
+  th.start Thing::B
+end
+
+w.evolve 100

data/examples/lotka-volterra.rb

@@ -0,0 +1,33 @@
+require 'redshift'
+
+class Population < RedShift::Component
+  flow do
+    diff " rabbits' = 0.3*rabbits - 0.02 * rabbits * foxes "
+    diff " foxes'   = 0.01*foxes*rabbits - 0.5 * foxes "
+  end
+end
+
+world = RedShift::World.new do |w|
+  w.time_step = 0.05
+end
+
+pop = world.create Population
+pop.foxes = 2
+pop.rabbits = 100
+
+data = []
+world.evolve 100 do |w|
+  data << [w.clock, pop.foxes, pop.rabbits]
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "Lotla-Volterra"}
+  plot.command %{set xlabel "time"}
+  plot.add data, %{using 1:2 title "foxes" with lines}
+  plot.add data, %{using 1:3 title "rabbits" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM

data/examples/persist-ball.rb

@@ -0,0 +1,68 @@
+require 'redshift'
+require 'plot/plot'
+require 'nr/random'
+
+include RedShift
+include NR::Random
+include Math
+
+
+class Ball < Component
+
+  flow {
+    euler " x' = @vx "
+    euler " y' = @vy "
+  }
+  
+  defaults {
+    @x = 0
+    @y = 0
+  }
+  
+end
+
+world = World.open "ball.world"
+
+unless world
+
+  world = World.new {time_step 0.01}
+
+  seq = UniformSequence.new :min => 0, :max => 2*PI
+
+  5.times do
+    world.create(Ball) {
+      angle = seq.next
+      @vx = cos angle
+      @vy = sin angle
+    }
+  end
+  
+end
+
+balls = world.select { |c| c.type == Ball }
+
+data = {}
+for b in balls
+  data[b] = [[b.x, b.y]]
+end
+
+50.times do
+  world.run
+  for b in balls
+    data[b] << [b.x, b.y]
+  end
+end
+
+Plot.new ('gnuplot') {
+
+  command 'set xrange [ -2 : 2 ]; set yrange [ -2 : 2 ]'
+  
+  for b in balls
+    add data[b], "title \"#{balls.index(b)}\" with lines"
+  end
+  
+  show
+  pause 5
+}
+
+world.save "ball.world"

data/examples/pid.rb

@@ -0,0 +1,87 @@
+# PID control example
+# See http://en.wikipedia.org/wiki/PID_control.
+
+require 'redshift'
+include RedShift
+
+srand(12345)
+
+# Variable with discrete and continuous perturbation.
+class Plant < Component
+  continuous :x => 0, :t => 1
+  
+  link :control => :Control # fwd ref to undefined class Control
+  
+  flow do
+    diff " x' = control.output + sin(t) "
+    diff " t' = -1 "
+  end
+  
+  transition do
+    guard "t <= 0"
+    action do
+      self.t += rand * 20
+      self.x += (rand - 0.5) * 10
+    end
+  end
+end
+
+# Tries to bring x back to the set_point.
+class Control < Component
+  continuous :set_point => 2.0
+  continuous :p_out, :i_out, :d_out, :output
+  
+  # Gains
+  constant :k_p => 1.0,
+           :k_i => 1.0,
+           :k_d => 1.0
+  
+  link :plant => Plant
+  
+  flow do
+    algebraic     " error   = set_point - plant.x "
+    algebraic     " p_out   = k_p * error "
+    differential  " i_out'  = k_i * error "
+    algebraic     " d_out   = k_d * (- sin(plant.t)) "
+      # since in plant we have x' = control.output + sin(t)
+      # and we can algebraically remove the "output" term.
+      # this is a special case that doesn't need numerical differentiation
+    algebraic     " output  = p_out + i_out + d_out "
+  end
+end
+
+world = World.new
+plant = world.create Plant
+control = world.create Control
+control.plant = plant
+plant.control = control
+
+x, p_out, i_out, d_out, output = [], [], [], [], []
+gather = proc do
+  time = world.clock
+  x       << [time, plant.x]
+  p_out   << [time, control.p_out]
+  i_out   << [time, control.i_out]
+  d_out   << [time, control.d_out]
+  output  << [time, control.output]
+end
+
+gather.call
+world.evolve 1000 do
+  gather.call
+end
+
+require 'sci/plot'
+include Plot::PlotUtils
+
+gnuplot do |plot|
+  plot.command %{set title "PID control"}
+  plot.command %{set xlabel "time"}
+  plot.add x, %{title "x" with lines}
+  plot.add p_out, %{title "p_out" with lines}
+  plot.add i_out, %{title "i_out" with lines}
+  plot.add d_out, %{title "d_out" with lines}
+  plot.add output, %{title "output" with lines}
+end
+
+sleep 1 if /mswin32|mingw32/ =~ RUBY_PLATFORM

data/examples/ports.rb

@@ -0,0 +1,60 @@
+# Shows how to use the port abstraction to refer to ports independently of the
+# components (and classes) they are attached to.
+
+require 'redshift'
+include RedShift
+
+class I < Component
+  flow do
+    diff " x' = -x "
+  end
+end
+
+class A < Component
+  flow do
+    diff " t' = 1 "
+    alg  " x  = cos(t) "
+  end
+end
+
+class K < Component
+  constant :x => 5.678
+end
+
+class W < Component
+  input :x
+  setup do
+    port(:x) << create(I).port(:x)
+  end
+end
+
+class L < Component
+  link :i => I
+  setup do
+    self.i = create(I)
+  end
+  flow do
+    alg " x = i.x "
+  end
+end
+
+class Tester < Component
+  input :x
+end
+
+w = World.new
+
+comps = [I, A, K, W, L].map {|cl| w.create(cl)}
+ports = comps.map {|comp| comp.port(:x)}
+values = ports.map {|port| port.value}
+
+p values # ==> [0.0, 1.0, 5.678, 0.0, 0.0]
+
+tester = w.create(Tester)
+values = ports.map do |port|
+  tester.port(:x) << port
+  tester.x
+end
+
+p values # same as above
+