y_petri 2.1.3 → 2.1.6

data/lib/y_petri/simulation/elements.rb

@@ -1,8 +1,10 @@
+# encoding: utf-8
+
 # Basic elements of a simulation, a mixin intended for YPetri::Simulation.
 #
 class YPetri::Simulation
   class Elements < Array
-    include Dependency
+    ★ Dependency
     
     class << self
       # New collection constructor

data/lib/y_petri/simulation/feature_set.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 # Basic elements of a simulation, a mixin intended for YPetri::Simulation.
 #
 class YPetri::Simulation
   # Represents a set of features of a simulation state.
   # 
   class FeatureSet
-    include DependencyInjection
+    ★ DependencyInjection
 
     attr_reader :marking, :firing, :delta
 

data/lib/y_petri/simulation/marking_vector.rb

@@ -1,8 +1,10 @@
+# encoding: utf-8
+
 # Basic elements of a simulation, a mixin intended for YPetri::Simulation.
 #
 class YPetri::Simulation
   class MarkingVector < Matrix
-    include Dependency
+    ★ Dependency
 
     class << self
       include Dependency

data/lib/y_petri/simulation/place_mapping.rb

@@ -1,8 +1,10 @@
+# encoding: utf-8
+
 # Manages the initial marking of a simulation.
 # 
 class YPetri::Simulation
   class PlaceMapping < Hash
-    include Dependency
+    ★ Dependency
 
     class << self
       # Initializes the initial marking from a hash.

data/lib/y_petri/simulation/places.rb

@@ -7,7 +7,7 @@ require_relative 'places/clamped'
 # Place collection for YPetri::Simulation.
 #
 class YPetri::Simulation::Places
-  include Types
+  ★ Types
 
   # Pushes a place to the collection.
   # 

data/lib/y_petri/simulation/recorder.rb

@@ -1,54 +1,60 @@
-class YPetri::Simulation
-  # A machine that receives alerts during simulation and records a recording
-  # according to its implementation. Alerts are received via +#alert+ method.
-  # The recording bein recorded is stored in @recording instance variable.
-  # This can be reset by +#reset!+ method, which also accepts arguments to
-  # change the recorder settings and/or insert another recording.
-  #
-  class Recorder
-    include Dependency
-
-    SAMPLING_DECIMAL_PLACES = 5
-
-    attr_reader :features, :recording
-    delegate :simulation, to: "self.class"
-    delegate :reconstruct, :reduce, to: :recording
-
-    # Initializes the recorder. Takes 2 arguments: +:features+ expecting the
-    # feature set to record during simulation, and +:recording+, expecting the
-    # initial state of the recording.
-    # 
-    def initialize features: net.State.marking( free_pp ),
-                   recording: features.new_dataset,
-                   **nn
-      @features = net.State.features( features )
-      reset! recording: recording
-    end
-
-    # Assigns to @recording a new Dataset instance. Without arguments, the new
-    # recording is empty. With +:recording+ named argument supplied, the new
-    # recording is filled with the prescribed contents.
-    # 
-    def reset! **nn
-      @features = net.State.features( nn[:features] || @features )
-      @recording = features.new_dataset
-      @recording.update Hash[ nn[:recording] ] if nn[:recording]
-    end
-
-    # Hook to be called by simulators whenever there is a state change. The
-    # decision to sample is then the business of the recorder.
-    # 
-    def alert
-      sample! # vanilla recorder samples at every occasion
-    end
-
-    private
-
-    # Records the current state as a pair { sampling_event => system_state }.
-    # 
-    def sample! event
-      record = simulation.get_features( features )
-      recording[ event ] = record.dump( precision: SAMPLING_DECIMAL_PLACES )
-    end
-  end # class Recorder
-end # YPetri::Simulation
+# encoding: utf-8
+
+# A machine that receives alerts during simulation and records a recording
+# according to its implementation. Alerts are received via +#alert+ method.
+# The recording bein recorded is stored in @recording instance variable.
+# This can be reset by +#reset!+ method, which also accepts arguments to
+# change the recorder settings and/or insert another recording.
+#
+class YPetri::Simulation::Recorder
+  ★ YPetri::Simulation::Dependency
+
+  SAMPLING_DECIMAL_PLACES = 5
+
+  attr_reader :features, :recording
+  delegate :simulation, to: "self.class"
+  delegate :reconstruct, :reduce, to: :recording
+
+  # Initializes the recorder. Takes 2 arguments: +:features+ expecting the
+  # feature set to record during simulation, and +:recording+, expecting the
+  # initial state of the recording.
+  # 
+  def initialize features: net.State.marking( free_pp ),
+                 recording: nil,
+                 **nn
+    @features = net.State.features( features )
+    if recording then reset! recording: recording else reset! end
+  end
+
+  # Construct a new recording based on +features+.
+  # 
+  def new_recording
+    features.new_dataset
+  end
+
+  # Assigns to @recording a new Dataset instance. Without arguments, the new
+  # recording is empty. With +:recording+ named argument supplied, the new
+  # recording is filled with the prescribed contents.
+  # 
+  def reset! **nn
+    @features = net.State.features( nn[:features] || @features )
+    @recording = new_recording
+    @recording.update Hash[ nn[:recording] ] if nn[:recording]
+  end
+
+  # Hook to be called by simulators whenever there is a state change. The
+  # decision to sample is then the business of the recorder.
+  # 
+  def alert
+    sample! # vanilla recorder samples at every occasion
+  end
+
+  private
+
+  # Records the current state as a pair { sampling_event => system_state }.
+  # 
+  def sample! event
+    record = simulation.get_features( features )
+    recording[ event ] = record.dump( precision: SAMPLING_DECIMAL_PLACES )
+  end
+end # class YPetri::Simulation::Recorder

data/lib/y_petri/simulation/timed/recorder.rb

@@ -19,6 +19,12 @@ module YPetri::Simulation::Timed
       @next_time = next_time
     end
 
+    # Construct a new recording based on +features+.
+    # 
+    def new_recording
+      features.new_dataset type: :timed
+    end
+
     # Like +YPetri::Simulation::Recorder#reset+, but allowing for an additional
     # named argument +:next_time+ that sets the next sampling time, and
     # +:sampling:, resetting the sampling period.
@@ -37,7 +43,12 @@ module YPetri::Simulation::Timed
       t2 = next_time.round( 9 )
       if t >= t2 then # it's time to sample
         sample!
-        @next_time += sampling
+        begin
+          @next_time += sampling
+        rescue NoMethodError => err
+          ( puts "Here go error #{err}"; Kernel::p @next_time; Kernel::p sampling )
+        end
+                                      
       end
     end
 

data/lib/y_petri/simulation/timed.rb

@@ -1,184 +1,185 @@
 # encoding: utf-8
 
-class YPetri::Simulation
-  # A mixin for timed simulations, used by an +#extend+ call during init.
-  # 
-  module Timed
-    require_relative 'timed/recorder'
-
-    DEFAULT_SETTINGS = -> do { step: 0.1, sampling: 5, time: 0..60 } end
-
-    def self.included receiver
-      receiver.Recording.class_exec { prepend Recording }
-    end
-
-    # True for timed simulations.
-    # 
-    def timed?
-      true
-    end
-
-    attr_reader :time,
-                :time_unit,
-                :initial_time,
-                :target_time,
-                :step,
-                :default_sampling
-
-    alias starting_time initial_time
-    alias ending_time target_time
-
-    delegate :flux_vector_TS,
-             :gradient_TS,
-             :gradient_Ts,
-             :gradient,
-             :flux_vector,
-             to: :core
-
-    delegate :sampling, to: :recorder
-
-    # Reads the time range (initial_time..target_time) of the simulation.
-    #
-    def time_range
-      initial_time..target_time
-    end
-
-    # Returnst the settings pertaining to the Timed aspect of the simulation,
-    # that is, +:step+, +:sampling+ and +:time+.
-    #
-    def settings all=false
-      super.update( step: step,
-                    sampling: sampling,
-                    time: time_range )
-    end
-
-    # Same as +#run!+, but guards against run upto infinity.
-    #
-    def run( upto: target_time, final_step: :exact )
-      fail "Upto time equals infinity!" if upto == Float::INFINITY
-      run!( upto: upto, final_step: final_step )
-    end
-
-    # Near alias for +#run_upto+. Accepts +:upto+ named argument, using
-    # @target_time attribute as a default. The second optional argument,
-    # +:final_step+, has the same options as in +#run_upto+ method.
-    #
-    def run!( upto: target_time, final_step: :exact )
-      run_upto( upto, final_step: final_step )
-    end
-
-    # Runs the simulation until the target time. Named argument :final_step has
-    # options :just_before, :just_after and :exact, and tunes the simulation
-    # behavior towards the end of the run.
-    #
-    # just_before:     last step has normal size, simulation stops before or just
-    #                  on the target time
-    # just_after:      last step has normal size, simulation stops after or just
-    #                  on the target time_step
-    # exact:           simulation stops exactly on the prescribed time, last step
-    #                  is shortened if necessary
-    #
-    def run_upto( target_time, final_step: :exact )
-      case final_step
-      when :before then
-        step! while time + step <= target_time
-      when :exact then
-        step! while time + step < target_time
-        step!( target_time - time )
-        @time = target_time
-      when :after then
-        step! while time < target_time
-      else
-        fail ArgumentError, "Unrecognized :final_step option: #{final_step}"
-      end
-    end
-
-    # String representation of this timed simulation.
-    # 
-    def to_s
-      "#<Simulation: time: %s, pp: %s, tt: %s, oid: %s>" %
-        [ time, pp.size, tt.size, object_id ]
-    end
+# A mixin for timed simulations, used by an +#extend+ call during init.
+# 
+module YPetri::Simulation::Timed
+  require_relative 'timed/recorder'
 
-    # Increments the simulation's time and alerts the recorder.
-    #
-    def increment_time! Δt=step
-      @time += Δt
-      recorder.alert
-    end
+  DEFAULT_SETTINGS = -> do { step: 0.1, sampling: 5, time: 0..60 } end
 
-    # Resets the timed simulation.
-    #
-    def reset!
-      @time = initial_time || time_unit * 0
-      super
+  # True for timed simulations.
+  # 
+  def timed?
+    true
+  end
+
+  attr_reader :time,
+              :time_unit,
+              :initial_time,
+              :target_time,
+              :step,
+              :default_sampling
+
+  alias starting_time initial_time
+  alias ending_time target_time
+
+  delegate :flux_vector_TS,
+           :gradient_TS,
+           :gradient_Ts,
+           :gradient,
+           :flux_vector,
+           to: :core
+
+  delegate :sampling, to: :recorder
+
+  # Reads the time range (initial_time..target_time) of the simulation.
+  #
+  def time_range
+    initial_time..target_time
+  end
+
+  # Returnst the settings pertaining to the Timed aspect of the simulation,
+  # that is, +:step+, +:sampling+ and +:time+.
+  #
+  def settings all=false
+    super.update( step: step,
+                  sampling: sampling,
+                  time: time_range )
+  end
+
+  # Same as +#run!+, but guards against run upto infinity.
+  #
+  def run( upto: target_time, final_step: :exact )
+    fail "Upto time equals infinity!" if upto == Float::INFINITY
+    run!( upto: upto, final_step: final_step )
+  end
+
+  # Near alias for +#run_upto+. Accepts +:upto+ named argument, using
+  # @target_time attribute as a default. The second optional argument,
+  # +:final_step+, has the same options as in +#run_upto+ method.
+  #
+  def run!( upto: target_time, final_step: :exact )
+    run_upto( upto, final_step: final_step )
+  end
+
+  # Runs the simulation until the target time. Named argument :final_step has
+  # options :just_before, :just_after and :exact, and tunes the simulation
+  # behavior towards the end of the run.
+  #
+  # just_before:     last step has normal size, simulation stops before or just
+  #                  on the target time
+  # just_after:      last step has normal size, simulation stops after or just
+  #                  on the target time_step
+  # exact:           simulation stops exactly on the prescribed time, last step
+  #                  is shortened if necessary
+  #
+  def run_upto( target_time, final_step: :exact )
+    case final_step
+    when :before then
+      step! while time + step <= target_time
+    when :exact then
+      step! while time + step < target_time
+      step!( target_time - time )
+      @time = target_time
+    when :after then
+      step! while time < target_time
+    else
+      fail ArgumentError, "Unrecognized :final_step option: #{final_step}"
     end
+  end
 
-    # Customized dup method that allows to modify the attributes of
-    # the duplicate upon creation.
-    #
-    def dup time: time, **nn
-      super( **nn ).tap { |i| i.reset_time! time }
-    end
-    alias at dup
-
-    # Returns the zero gradient. Optionally, places can be specified, for which
-    # the zero vector is returned.
-    #
-    def zero_gradient places: nil
-      return zero_gradient places: places() if places.nil?
-      places.map { |id|
-        p = place( id )
-        ( p.free? ? p.initial_marking : p.clamp ) * 0 / time_unit
-      }.to_column_vector
-    end
-    alias zero_∇ zero_gradient
-
-    private
-
-    # Initialization subroutine for timed simulations. Expects named arguments
-    # +:time+ (alias +:time_range+), meaning the simulation time range (a Range
-    # of initial_time..target_time), +:step+, meaning time step of the
-    # simulation, and +:sampling+, meaning sampling period of the simulation.
-    #
-    # Initializes the time-related attributes @initial_time, @target_time,
-    # @time_unit and @time (via +#reset_time!+ call). Also sets up the
-    # parametrized subclasses +@Core+ and +@Recorder+, and initializes the
-    # +@recorder+ attribute.
-    #
-    def init **settings
-      if settings.has? :time, syn!: :time_range then # time range given
+  # String representation of this timed simulation.
+  # 
+  def to_s
+    "#<Simulation: time: %s, pp: %s, tt: %s, oid: %s>" %
+      [ time, pp.size, tt.size, object_id ]
+  end
+
+  # Increments the simulation's time and alerts the recorder.
+  #
+  def increment_time! Δt=step
+    @time += Δt
+    recorder.alert
+  end
+
+  # Resets the timed simulation.
+  #
+  def reset! **nn
+    @time = initial_time || time_unit * 0
+    super
+  end
+
+  # Customized dup method that allows to modify the attributes of
+  # the duplicate upon creation.
+  #
+  def dup time: time, **nn
+    super( **nn ).tap { |i| i.reset_time! time }
+  end
+  alias at dup
+
+  # Returns the zero gradient. Optionally, places can be specified, for which
+  # the zero vector is returned.
+  #
+  def zero_gradient places: nil
+    return zero_gradient places: places() if places.nil?
+    places.map { |id|
+      p = place( id )
+      ( p.free? ? p.initial_marking : p.clamp ) * 0 / time_unit
+    }.to_column_vector
+  end
+  alias zero_∇ zero_gradient
+
+  private
+
+  # Initialization subroutine for timed simulations. Expects named arguments
+  # +:time+ (alias +:time_range+), meaning the simulation time range (a Range
+  # of initial_time..target_time), +:step+, meaning time step of the
+  # simulation, and +:sampling+, meaning sampling period of the simulation.
+  #
+  # Initializes the time-related attributes @initial_time, @target_time,
+  # @time_unit and @time (via +#reset_time!+ call). Also sets up the
+  # parametrized subclasses +@Core+ and +@Recorder+, and initializes the
+  # +@recorder+ attribute.
+  #
+  def init **settings
+    if settings.has? :time, syn!: :time_range then # time range given
+      case settings[:time]
+      when Range then
         time_range = settings[:time]
         @initial_time, @target_time = time_range.begin, time_range.end
-        @time_unit = target_time / target_time.to_f
+        @time_unit = initial_time.class.one
       else
-        anything = settings[:step] || settings[:sampling]
-        msg = "The simulation is timed, but the constructor lacks any of the " +
-          "time-related arguments: :time, :step, or :sampling!"
-        fail ArgumentError, msg unless anything
-        @time_unit = anything / anything.to_f
-        @initial_time, @target_time = time_unit * 0, time_unit * Float::INFINITY
+        @initial_time = settings[:time]
+        @time_unit = initial_time.class.one
+        @target_time = time_unit * Float::INFINITY
       end
-      init_core_and_recorder_subclasses
-      reset_time!
-      @step = settings[:step] || time_unit
-      @default_sampling = settings[:sampling] || step
-      @recorder = Recorder().new sampling: settings[:sampling]
-    end
-
-    # Sets up subclasses of +Core+ (the simulator) and +Recorder+ (the sampler)
-    # for timed simulations.
-    # 
-    def init_core_and_recorder_subclasses
-      param_class( { Core: YPetri::Core::Timed,
-                     Recorder: Recorder },
-                   with: { simulation: self } )
+    else
+      anything = settings[:step] || settings[:sampling]
+      msg = "The simulation is timed, but the constructor lacks any of the " +
+        "time-related arguments: :time, :step, or :sampling!"
+      fail ArgumentError, msg unless anything
+      @time_unit = anything.class.one
+      @initial_time, @target_time = time_unit * 0, time_unit * Float::INFINITY
     end
-
-    # Resets the time to initial time, or to the argument (if provided).
-    #
-    def reset_time! time=nil
-      @time = time.nil? ? initial_time : time
-    end
-  end # module Timed
+    init_core_and_recorder_subclasses
+    reset_time!
+    @step = settings[:step] || time_unit
+    @default_sampling = settings[:sampling] || step
+    @recorder = Recorder().new sampling: settings[:sampling]
+  end
+
+  # Sets up subclasses of +Core+ (the simulator) and +Recorder+ (the sampler)
+  # for timed simulations.
+  # 
+  def init_core_and_recorder_subclasses
+    param_class( { Core: YPetri::Core::Timed,
+                   Recorder: Recorder },
+                 with: { simulation: self } )
+  end
+
+  # Resets the time to initial time, or to the argument (if provided).
+  #
+  def reset_time! time=nil
+    @time = time.nil? ? initial_time : time
+  end
 end # module YPetri::Simulation::Timed