redshift 1.3.15

data/test/test_connect.rb

@@ -0,0 +1,242 @@
+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
+  input :yy # usually unused, so doesn't need to be connected
+  link :other => B
+  
+  flow do
+    alg " z = y+1 "
+    alg " w = y + yy "
+    alg " u = other.y "
+  end
+  transition Enter => Exit do
+    guard "y < 0"
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestConnect < Test::Unit::TestCase
+
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+    @a = @world.create(A)
+    @b = @world.create(B)
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_unconnected
+    assert_raises(UnconnectedInputError) do
+      @b.y
+    end
+    
+    assert_raises(NoMethodError) do
+      @b.y = 1.23
+    end
+
+    assert_raises(UnconnectedInputError) do
+      @world.evolve 1
+    end
+
+    assert_raises(UnconnectedInputError) do
+      @b.z
+    end
+  end
+    
+  def test_not_connectable
+    assert_raises(TypeError) do
+      @a.port(:x) << @b.port(:y)
+    end
+    assert_raises(TypeError) do
+      @a.connect(:x, @b, :y)
+    end
+  end
+  
+  def test_connect
+    @b.connect(:y, @a, :x)
+    @a.x = 4.56
+    
+    assert_equal(@a.x, @b.y)
+    assert_equal(@b.y+1, @b.z)
+    @world.evolve 1 do
+      assert_equal(@a.x, @b.y)
+      assert_equal(@b.y+1, @b.z)
+    end
+    
+    # reconnect to different var (actually a constant)
+    @b.connect(:y, @a, :k)
+
+    assert_equal(@a.k, @b.y)
+    assert_equal(@b.y+1, @b.z)
+    @world.evolve 1 do
+      assert_equal(@a.k, @b.y)
+      assert_equal(@b.y+1, @b.z)
+    end
+    
+    # disconnect
+    @b.disconnect(:y)
+    
+    assert_raises(UnconnectedInputError) do
+      @b.z
+    end
+
+    assert_raises(UnconnectedInputError) do
+      @b.y
+    end
+
+    # nothing raised:
+    @b.disconnect(:y)
+    
+    # reconnect to different component (using ports)
+    @a = @world.create(A)
+    @b.port(:y) << @a.port(:x)
+
+    @a.x = 7.89
+    
+    assert_equal(@a.x, @b.y)
+    assert_equal(@a.x, @b.port(:y).value)
+    assert_equal(@b.y+1, @b.z)
+    @world.evolve 1 do
+      assert_equal(@a.x, @b.y)
+      assert_equal(@b.y+1, @b.z)
+    end
+  end
+  
+  def test_reflection
+    @b.connect(:y, @a, :x)
+    
+    assert_equal(@a.port(:x), @b.port(:y).source)
+    assert_equal(@a, @b.port(:y).source_component)
+    assert_equal(:x, @b.port(:y).source_variable)
+
+    assert_equal(@a, @a.port(:x).component)
+    assert_equal(:x, @a.port(:x).variable)
+  end
+  
+  def test_disconnect
+    @b.connect(:y, @a, :x)
+    @b.disconnect(:y)
+    assert_equal(nil, @b.port(:y).source)
+
+    @b.port(:y).disconnect
+    assert_equal(nil, @b.port(:y).source)
+
+    @b.port(:y) << nil
+    assert_equal(nil, @b.port(:y).source)
+
+    assert_raises(UnconnectedInputError) do
+      @b.y
+    end
+  end
+  
+  def test_connect_to_input
+    b2 = @world.create(B)
+    @b.port(:y) << @a.port(:x)
+    b2.port(:y) << @b.port(:y)
+    @a.x = 3.456
+    assert_equal(@b.y, b2.y)
+    assert_equal(@a.x, b2.y)
+    assert_equal(b2.y+1, b2.z)
+  end
+  
+  def test_connect_input_chain
+    b = (0..99).map {@world.create(B)}
+    (0..98).each do |i|
+      b[i+1].port(:y) << b[i].port(:y)
+    end
+    b[0].port(:y) << @a.port(:x)
+
+    @a.x = 42.4242
+    assert_equal(@a.x, b[99].y)
+    assert_equal(@a.x, b[0].y)
+    
+    old_b_50 = b[50]
+    b[50] = @world.create(B)
+    b[50].port(:y) << b[49].port(:y)
+    b[51].port(:y) << b[50].port(:y)
+
+    @a.x = 987.789
+    assert_equal(@a.x, b[99].y)
+    assert_equal(@a.x, b[0].y)
+    assert_equal(@a.x, old_b_50.y)
+  end
+  
+  def make_circle n
+    b = (0...n).map {@world.create(B)}
+    n.times do |i|
+      b[i].port(:y) << b[(i+1)%n].port(:y)
+    end
+    b
+  end
+    
+  def test_connect_input_circular
+    [1, 2, 3, 10].each do |n|
+      b = make_circle(n)
+      assert_raises(RedShift::CircularDefinitionError) do
+        b[0].y
+      end
+    end
+  end
+  
+  def test_connect_input_flow
+    b = (0..5).map {@world.create(B)}
+    (0..4).each do |i|
+      b[i+1].port(:y) << b[i].port(:y)
+    end
+    b[0].port(:y) << @a.port(:x)
+        
+    @b.port(:y) << @a.port(:x) # ust so guard doesn't find y unconn.
+
+    @a.x = 1.0
+    assert_equal(@a.x, b[5].y)
+    assert_equal(@a.x, b[0].y)
+
+    @world.evolve 10
+    assert_equal(@a.x, b[5].y)
+    assert_equal(@a.x, b[0].y)
+  end
+
+  def test_connect_input_multiple
+    @b.port(:y) << @a.port(:x)
+    @b.port(:yy) << @b.port(:y) # Can connect to another var in self!
+    @a.x = 1.0
+    assert_equal(@a.x*2, @b.w)
+  end
+  
+  def test_linked_input
+    @a.x = 99.876
+    
+    @b.other = @world.create(B)
+    @b.other.port(:y) << @a.port(:k)
+
+    assert_equal(@b.other.y, @a.k)
+    assert_equal(@b.other.y, @b.u)
+  end
+  
+  def test_marshal
+    @a.x = -3.21
+    @b.port(:y) << @a.port(:x)
+    assert_equal(@a.x, @b.y)
+
+    world2 = Marshal.load(Marshal.dump(@world))
+    a = world2.grep(A).first
+    b = world2.grep(B).first
+    assert_equal(a.x, b.y)
+  end
+end

data/test/test_connect_parallel.rb

@@ -0,0 +1,47 @@
+require "redshift"
+include RedShift
+
+class A < Component
+  input :in
+  continuous :x => 1
+  link :comp
+  
+  state :T
+  
+  flow T do
+    diff " x' = in "
+  end
+  
+  transition Enter => T do
+    reset :comp => nil
+    connect :in => proc {comp.port(:x)}
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestConnect < Test::Unit::TestCase
+
+  def setup
+    @world = World.new
+    @world.time_step = 0.001
+    @a0 = @world.create(A)
+    @a1 = @world.create(A)
+    @a0.comp = @a1
+    @a1.comp = @a0
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_evolve
+    @world.evolve 1
+    [@a0, @a1].each do |a|
+      assert_in_delta(Math::E, a.in, 1.0e-12)
+      assert_equal(nil, a.comp)
+    end
+  end
+end

data/test/test_connect_strict.rb

@@ -0,0 +1,135 @@
+require "redshift"
+include RedShift
+
+class A < Component
+  continuous :ns_x
+  strictly_continuous :x
+
+  constant :ns_k
+  strictly_constant :k => 6.78
+
+  flow do
+    diff " x' = 2*x "
+  end
+end
+
+class B < Component
+  strict_input :y
+  transition Enter => Exit do
+    name "t"
+    guard "y > 5"
+  end
+end
+
+class Dummy < Component
+  state :S, :T, :U
+  setup do
+    start S
+  end
+  
+  flow S do
+    diff "time' = 1"
+  end
+  
+  transition S => T do
+    guard "time > 0"
+    reset :time => 0 # so we do it again next timestep
+  end
+  
+  transition T => U, U => S
+end
+
+# From test_strict_continuity.rb
+class SCWorld < World
+  def num_checks
+    @num_checks ||= Hash.new do |h,comp|
+      h[comp] = Hash.new do |h1,trans|
+        h1[trans] = 0
+      end
+    end
+  end
+  
+  def hook_eval_guard(comp, guard, enabled, trans, dest)
+    num_checks[comp][trans.name] += 1
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestConnectStrict < Test::Unit::TestCase
+
+  def setup
+    @world = SCWorld.new
+    @world.time_step = 0.1
+    @a = @world.create(A) {|a| a.x = 1 }
+    @b = @world.create(B)
+    @world.create(Dummy)
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  # can connect strict_input *only* to strict var/const
+  def test_not_connectable
+    assert_raises(StrictnessError) do
+      @b.port(:y) << @a.port(:ns_x)
+    end
+    assert_raises(StrictnessError) do
+      @b.port(:y) << @a.port(:ns_k)
+    end
+  end
+  
+  # can't disconnect strict_input that has been connected
+  def test_disconnect
+    @b.port(:y) << nil # ok
+    @b.port(:y) << @a.port(:x)
+    assert_raises(StrictnessError) do
+      @b.port(:y) << nil
+    end
+  end
+  
+  # can't connect to a different component
+  def test_reconnect_comp
+    @b.port(:y) << @a.port(:x)
+    @b.port(:y) << @a.port(:x) # ok
+    assert_raises(StrictnessError) do
+      @b.port(:y) << @world.create(A).port(:x)
+    end
+  end
+
+  # can't connect to a different var in same component
+  def test_reconnect_var
+    @b.port(:y) << @a.port(:x)
+    assert_raises(StrictnessError) do
+      @b.port(:y) << @a.port(:k)
+    end
+  end
+  
+  # can reconnect if value is the same
+  def test_reconnect_same_value
+    a = @world.create(A) do |a|
+      a.x = a.k = 12.34
+    end
+    @b.port(:y) << a.port(:x)
+    assert_nothing_raised do
+      @b.port(:y) << a.port(:k)
+    end
+  end
+  
+  # One check per step, despite the Dummy
+  def test_strict_guard
+    @b.port(:y) << @a.port(:x)
+    prev = nil
+    @world.evolve 2 do
+      if @b.state == Enter
+        if prev
+          assert_equal(prev + 1, @world.num_checks[@b]["t"])
+        end
+        prev = @world.num_checks[@b]["t"]
+      end
+    end
+  end
+end

data/test/test_constant.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+class ConstantTestComponent < Component
+  def finish test
+  end
+  
+  constant :k
+  strictly_constant :ks
+  
+  link :other => ConstantTestComponent
+  
+  state :HasOther, :Stop
+  
+  transition Enter => HasOther do
+    guard "other"
+  end
+  
+  flow HasOther do
+    diff "x' = other.k + k + other.ks + ks"
+    diff "t' = 1"
+  end
+  
+  transition HasOther => Stop do
+    guard "t >= 1"
+    action do
+      @y = other.k + k + other.ks + ks
+    end
+  end
+  
+  def assert_consistent test
+    if t >= 1
+      test.assert_in_delta(44, x, 1E-10)
+      test.assert_equal(44, @y)
+    end
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestConstant < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_constant
+    comp1 = @world.create(ConstantTestComponent) do |c1|
+      c1.k = 1.0
+      c1.ks = 10.0
+    end
+    
+    comp2 = @world.create(ConstantTestComponent) do |c2|
+      c2.k = 3.0
+      c2.ks = 30.0
+    end
+    
+    comp1.other = comp2
+    testers = [comp1, comp2]
+        
+    @world.run 20
+    comp1.assert_consistent self
+  end
+end
+