redshift 1.3.15

data/test/test_discrete_isolated.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+=begin
+
+This file runs tests that have to be done without the presence of other objects in the world. Each test is performed in a separate world.
+
+=end
+
+class DiscreteIsolatedTestComponent < Component
+  def initialize(*args)
+    super
+    @t = world.clock
+  end
+end
+
+# transitions with no body keep the discrete step alive
+
+class DiscreteIsolated_1 < DiscreteIsolatedTestComponent
+  prev = Enter
+  for state_name in "State_01".."State_10"
+    state state_name
+    
+    curr = const_get(state_name)
+    
+    flow prev do
+      diff "x' = 1"
+    end
+
+    transition prev => curr
+    prev = curr
+  end
+  @@last = prev
+
+  def assert_consistent test
+    test.assert_equal(@@last, state)
+    test.assert_in_delta(0, x, 1.0E-20)
+  end
+end
+
+# transitions with just a guard keep the discrete step alive
+
+class DiscreteIsolated_2 < DiscreteIsolatedTestComponent
+  state :A, :B
+  flow A do
+    diff "x' = 1"
+  end
+  transition Enter => A, A => B do
+    guard {true}
+  end
+  def assert_consistent test
+    test.assert_equal(B, state)
+    test.assert_in_delta(0, x, 1.0E-20)
+  end
+end
+
+
+#-----#
+
+require 'test/unit'
+
+class TestDiscrete < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_discrete_isolated
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= DiscreteIsolatedTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        world = World.new
+        world.time_step = 0.1
+        testers << [world, world.create(cl)]
+      end
+    end
+    
+    for w,t in testers
+      w.run
+      t.assert_consistent self
+    end
+  end
+end

data/test/test_exit.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+# Tests that exited components do not evolve continuously or discretely.
+
+class ExitComponent < Component
+  strictly_continuous :x
+  flow do
+    diff "x' = 1"
+  end
+  
+  setup do
+    @guard_count = 0
+    @x_event_time = nil
+  end
+  
+  transition Enter => Exit do
+    guard {x > 0.5}
+  end
+  
+  transition Exit => Exit do
+    action {@transition_on_exit = true}
+  end
+
+  def assert_consistent(test)
+    test.assert(!@transition_on_exit)
+    test.assert(x < 0.61)
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestExit < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_exit
+    tc = @world.create(ExitComponent)
+    
+    tc.assert_consistent(self)
+    @world.run 10 do
+      tc.assert_consistent(self)
+    end
+    tc.assert_consistent(self)
+  end
+end
+

data/test/test_flow.rb

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+class FlowTestComponent < Component
+  def finish test
+  end
+end
+
+# Empty flows are constant.
+
+class Flow_Empty < FlowTestComponent
+  continuous :x
+  setup { self.x = 5 }
+  def assert_consistent test
+    test.assert_in_delta(5, x, 0.0000000000001)
+  end
+end
+
+# Make sure timers work!
+
+class Flow_Euler < FlowTestComponent
+  flow { euler "t' = 1" }
+  setup { self.t = 0 }
+  def assert_consistent test
+    test.assert_in_delta(world.clock, t, 0.0000000001)
+  end
+end
+
+# Alg flows.
+
+class Flow_Alg < FlowTestComponent
+  flow { alg "f = 1", "g = f + 2" }
+  def assert_consistent test
+    test.assert_in_delta(1, f, 0.0000000001)
+    test.assert_in_delta(3, g, 0.0000000001)
+  end
+end
+
+# Trig functions.
+
+class Flow_Sin < FlowTestComponent
+  flow { diff  "y' = y_prime", "y_prime' = -y" }
+  setup { self.y = 0; self.y_prime = 1 }
+  def assert_consistent test
+    test.assert_in_delta(sin(world.clock), y, 0.000000001)
+    ## is this epsilon ok? how does it compare with cshift?
+  end
+end
+
+# Exp functions.
+
+class Flow_Exp < FlowTestComponent
+  flow { diff  "y' = y" }
+  setup { self.y = 1 }
+  def assert_consistent test
+    test.assert_in_delta(exp(world.clock), y, 0.0001)
+  end
+end
+
+# Polynomials.
+
+class Flow_Poly < Flow_Euler    # note use of timer t from Flow_Euler
+  flow {
+    alg   "poly = -6 * pow(t,3) + 1.2 * pow(t,2) - t + 10"
+    diff  "y' = y1", "y1' = y2", "y2' = y3", "y3' = 0"
+  }
+  setup { self.y = 10; self.y1 = -1; self.y2 = 1.2 * 2; self.y3 = -6 * 3 * 2 }
+  def assert_consistent test
+    test.assert_in_delta(poly, y, 0.000000001, "at time #{world.clock}")
+  end
+end
+
+# test for detection of circularity and assignment to algebraically
+# defined vars
+
+class Flow_AlgebraicErrors < FlowTestComponent
+  flow {
+    alg "x = y"
+    alg "y = x"
+    alg "z = 1"
+  }
+  
+  def assert_consistent test
+    return if world.clock > 1
+    test.assert_raises(RedShift::CircularDefinitionError) {y}
+    test.assert_raises(RedShift::AlgebraicAssignmentError) {self.z = 2}
+  end
+end
+
+# Assignments to continuous vars force update of alg flows
+
+class Flow_AlgUpdate_Assignment < FlowTestComponent
+  flow {alg "y = x"}
+  continuous :x
+
+  def assert_consistent test
+    return if world.clock > 1
+    test.assert_in_delta(0, y, 1E-10);
+    self.x = 1
+    test.assert_in_delta(1, y, 1E-10);
+    self.x = 0
+  end
+end
+
+# Test that a diff flow that refers to an alg flow updates it during c.u. and
+# that the updated value is used in the next d.u. This is related to the 
+# var->d_tick assignment in step_continuous(). We're testing that the
+# optimization doesn't *prevent* the evaluation of y.
+class Flow_AlgDiff < FlowTestComponent
+  flow {
+    alg  " x = 3*y "
+    diff " y' = x  "
+  }
+  state :S1
+  default {self.y = 1}
+  transition Enter => S1 do
+    guard "y > 5"
+    action {@x = x; @y = y}
+  end
+  
+  def assert_consistent test
+    if @x
+      test.assert_in_delta(3*@y, @x, 1E-10)
+      @x = @y = nil
+    end
+  end
+end
+
+## TO DO ##
+=begin
+ 
+ varying time step (dynamically?)
+ 
+ handling of syntax errors
+ 
+=end
+
+###class Flow_MixedType < FlowTestComponent
+###  flow  {
+###    euler "w' = 4"
+###    diff  "x' = w"
+###    diff  "y' = 4"
+###    diff  "z' = y"  ### fails if these are more complex than just w or y
+###  }
+###  setup { self.w = self.y = 0; self.x = self.z = 0 }
+###  def assert_consistent test
+###    test.assert_in_delta(x, z, 0.001, "at time #{world.clock}")
+###  end
+###end
+
+
+#-----#
+
+require 'test/unit'
+
+class TestFlow < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step  = 0.01
+    @world.zeno_limit = 100
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_flow
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= FlowTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    testers.each { |t| t.assert_consistent self }
+    @world.run 1000 do
+      testers.each { |t| t.assert_consistent self }
+    end
+    testers.each { |t| t.finish self }
+  end
+end
+
+END {
+
+#  require 'plot/plot'
+#  Plot.new ('gnuplot') {
+#    add Flow_Reconfig::Y, 'title "y" with lines'
+#    add Flow_Reconfig::Y1, 'title "y1" with lines'
+#    add Flow_Reconfig::Y2, 'title "y2" with lines'
+#    add Flow_Reconfig::Y3, 'title "y3" with lines'
+#    show
+#    pause 5
+#  }
+
+}

data/test/test_flow_link.rb

@@ -0,0 +1,288 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+class FlowTestComponent < Component
+  def finish test
+  end
+end
+
+# test links in flows
+
+class Flow_UsingLink < FlowTestComponent
+  class Sub < Component
+    flow { diff "x' = 2" }
+  end
+  
+  link :sub => Sub
+  setup { self.sub = create Sub }
+  
+  flow {
+    diff "y' = sub.x"
+    diff "t' = 1"
+  }
+  
+  def assert_consistent test
+    test.assert_in_delta(
+      t**2,
+      y,
+      0.00000000001,
+      "in #{state.name} after #{t} sec,\n")
+  end
+  
+  def finish test
+#    puts "y = #{y} at time #{t}"
+  end
+end
+
+# test links in flows
+
+class Flow_UsingLink2 < FlowTestComponent
+  class Sub < Component
+    flow { alg "alg_dy = 2" }
+    flow { diff "diff_dy' = 0" }; default { self.diff_dy  = 2 }
+    continuous :const_dy; default { self.const_dy = 2 }
+  end
+  
+  link :sub => Sub
+  
+  setup do
+    self.sub = create Sub
+  end
+  
+  flow do
+    diff "t'  = 1"
+    diff "y'  = 2"
+    
+    diff "y1' = sub.alg_dy"
+    diff "y2' = sub.diff_dy"
+    diff "y3' = sub.const_dy"
+  end
+  
+  def assert_consistent test
+    test.assert_in_delta(y, y1, 0.00000000001,
+      "in #{state.name} after #{t} sec,\n")
+    test.assert_in_delta(y, y2, 0.00000000001,
+      "in #{state.name} after #{t} sec,\n")
+    test.assert_in_delta(y, y3, 0.00000000001,
+      "in #{state.name} after #{t} sec,\n")
+  end
+end
+
+# compare a system of equations in one component
+# with the same system distributed among several
+
+class Flow_UsingLink3 < FlowTestComponent
+  class Sub1 < Component; end
+  class Sub2 < Component; end
+
+  class Sub1
+    flow do
+      diff "x'  = 3*y + sub2.f"
+      diff "y'  = x + y*(0.1 * sub2.z - 0.2 * sub2.g)"
+#     diff "z'  = (f + y + z) * 0.1"
+#     alg  "f   = 0.3*(x + g) + 0.02"
+#     alg  "g   = 2*z + h"
+      alg  "h   = y - sub2.z + 1"
+    end
+    link :sub2 => Sub2
+  end
+  
+  class Sub2
+    flow do
+#     diff "x'  = 3*y + f"
+#     diff "y'  = x + y*(0.1 * z - 0.2 * g)"
+      diff "z'  = (f + sub1.y + z) * 0.1"
+      alg  "f   = 0.3*(sub1.x + g) + 0.02"
+      alg  "g   = 2*z + sub1.h"
+#     alg  "h   = y - z + 1"
+    end
+    link :sub1 => Sub1
+  end
+  
+  link :sub1 => Sub1
+  link :sub2 => Sub2
+  
+  setup do
+    self.sub1 = create Sub1
+    self.sub2 = create Sub2
+    
+    sub1.sub2 = sub2
+    sub2.sub1 = sub1
+  end
+  
+  flow do
+    diff "x'  = 3*y + f"
+    diff "y'  = x + y*(0.1 * z - 0.2 * g)"
+    diff "z'  = (f + y + z) * 0.1"
+    alg  "f   = 0.3*(x + g) + 0.02"
+    alg  "g   = 2*z + h"
+    alg  "h   = y - z + 1"
+  end
+  
+  def assert_consistent test
+    cmp = proc do |x, y| 
+      test.assert_in_delta(x, y, 0.00000000001,
+      "in #{state.name} after #{world.clock} sec,\n")
+    end
+    
+    cmp[x,sub1.x]
+    cmp[y,sub1.y]
+    cmp[z,sub2.z]
+    cmp[f,sub2.f]
+    cmp[g,sub2.g]
+    cmp[h,sub1.h]
+  end
+end
+
+# test "lnk ? lnk.z : w" and "lnk1 = lnk2 ? x : y"
+
+class Flow_Boolean < FlowTestComponent
+  class Sub < Component
+    flow {alg "x = 1"}
+  end
+  link :sub0 => Sub
+  link :sub1 => Sub
+  link :sub2 => Sub
+  setup {
+    self.sub1 = create Sub
+    self.sub2 = sub1
+  }
+  flow {
+    alg "y0 = sub1 ? sub1.x : 0"
+    alg "y1 = sub0 ? 0 : sub2.x"
+    alg "y2 = sub1 == sub2 ? sub1.x : 0"
+  }
+  def assert_consistent test
+    cmp = proc do |x, y| 
+      test.assert_in_delta(x, y, 0.00000000001,
+      "in #{state.name} after #{world.clock} sec,\n")
+    end
+    
+    cmp[1,y0]
+    cmp[1,y1]
+    cmp[1,y2]
+  end
+end
+
+# test error handling of nil links
+
+class Flow_NilLink < FlowTestComponent
+  class Sub < Component
+    continuous :z
+  end
+  link :nl => Sub
+  continuous :x
+  flow {alg "y = x ? nl.z : 0"}
+  def assert_consistent test
+    return true if x > 0
+    test.assert_raises(Flow::NilLinkError, "Didn't detect nil link.") do
+      self.x = 1
+      y
+    end
+  end
+end
+
+# test self links
+
+class Flow_SelfLink < FlowTestComponent
+  link :sl => Flow_SelfLink
+  setup {self.sl = self; self.y=1; self.z=1}
+  flow {diff "y' = sl.y"; diff "z'=z"}
+  def assert_consistent test
+    test.assert_in_delta(z, y, 0.00000000001)
+  end
+end
+
+# test dynamic reconfiguration in flows
+
+class Flow_Reconfig < FlowTestComponent
+  class Sub < Component
+    continuous :k; default { self.k = 2 }
+    flow { alg "dy = k" }
+  end
+  
+  link :sub => Sub
+  
+  setup do
+    @sub1 = create Sub
+    @sub2 = create Sub
+    @sub2.k = - @sub1.k
+    @next_t = 0
+  end
+  
+  state :Sub1, :Sub2
+  
+  continuous :dy; setup { self.dy = 2 }
+  
+  flow Sub1, Sub2 do
+    diff "y'  = sub.dy"
+    diff "y1' = dy"
+    diff "t'  = 1"
+  end
+  
+  transition Enter => Sub1, Sub2 => Sub1 do
+    guard { t >= @next_t }
+    action { self.sub = @sub1; @next_t += 1; self.dy = sub.dy }
+  end
+  
+  transition Sub1 => Sub2 do
+    guard { t >= @next_t }
+    action { self.sub = @sub2; @next_t += 1; self.dy = sub.dy }
+  end
+  
+  def assert_consistent test
+    test.assert_in_delta(y1, y, 0.00000000001,
+      "in #{state.name} after #{t} sec,\n")
+  end
+end
+
+
+#-----#
+
+require 'test/unit'
+
+class TestFlow < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step  = 0.01
+    @world.zeno_limit = 100
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_flow_link
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= FlowTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    testers.each { |t| t.assert_consistent self }
+    @world.run 100 do
+      testers.each { |t| t.assert_consistent self }
+    end
+    testers.each { |t| t.finish self }
+  end
+end
+
+END {
+
+#  require 'plot/plot'
+#  Plot.new ('gnuplot') {
+#    add Flow_Reconfig::Y, 'title "y" with lines'
+#    add Flow_Reconfig::Y1, 'title "y1" with lines'
+#    add Flow_Reconfig::Y2, 'title "y2" with lines'
+#    add Flow_Reconfig::Y3, 'title "y3" with lines'
+#    show
+#    pause 5
+#  }
+
+}