Changeset 17053 for stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1

stable

Property svn:mergeinfo changed
/trunk merged: 16779

stable/HeuristicLab.ExtLibs

Property svn:mergeinfo changed
/trunk/HeuristicLab.ExtLibs merged: 16779

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Analysis/ContinuousStatistics.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
   public sealed class ContinuousStatistics {
     private readonly Environment env;
+    private readonly Simulation env;
     public int Count { get; private set; }
 …
     public ContinuousStatistics(Environment env) {
+    public ContinuousStatistics(Simulation env) {
       this.env = env;
       lastUpdateTime = env.NowD;

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Collections/EventQueue.cs

-                      r15972
+                      r17053
   /// <summary>
   /// An implementation of a min-Priority Queue using a heap.  Has O(1) .Contains()!
   /// See https://bitbucket.org/BlueRaja/high-speed-priority-queue-for-c/wiki/Getting%20Started for more information
+  /// See https://github.com/BlueRaja/High-Speed-Priority-Queue-for-C-Sharp/wiki/Getting-Started for more information
   /// </summary>
   /// <remarks>
 …
     /// Removes every node from the queue.  O(n) (So, don't do this often!)
     /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Clear() {
       Array.Clear(_nodes, 1, _numNodes);
 …
     /// Returns (in O(1)!) whether the given node is in the queue.  O(1)
     /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public bool Contains(EventQueueNode node) {
       return (_nodes[node.QueueIndex] == node);
 …
     /// Enqueue a node - .Priority must be set beforehand!  O(log n)
     /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public EventQueueNode Enqueue(DateTime primaryPriority, Event @event, int secondaryPriority = 0) {
       var node = new EventQueueNode {
 …
       return node;
+    }
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     private void Swap(EventQueueNode node1, EventQueueNode node2) {
       //Swap the nodes
 …
+    }
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     private void CascadeDown(EventQueueNode node) {
       //aka Heapify-down
 …
     /// Note that calling HasHigherPriority(node, node) (ie. both arguments the same node) will return false
     /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     private bool HasHigherPriority(EventQueueNode higher, EventQueueNode lower) {
       return (higher.PrimaryPriority < lower.PrimaryPriority ||
 …
     /// O(log n)
     /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void UpdatePriority(EventQueueNode node, DateTime primaryPriority, int secondaryPriority) {
       node.PrimaryPriority = primaryPriority;

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/ActiveObject.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
   public abstract class ActiveObject<T> where T : Environment {
+  public abstract class ActiveObject<T> where T : Simulation {
     protected T Environment { get; private set; }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Environment.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
   /// <summary>
   /// Environments hold the event queues, schedule and process events.
+  /// Simulation hold the event queues, schedule and process events.
   /// </summary>
+  public class Environment {
+  /// <remarks>
+  /// This class is not thread-safe against manipulation of the event queue. If you supply a termination
+  /// event that is set outside the simulation, please use the <see cref="ThreadSafeSimulation"/> environment.
+  ///
+  /// For most purposes <see cref="Simulation"/> is however the better and faster choice.
+  /// </remarks>
+  public class Simulation {
     private const int InitialMaxEvents = 1024;
-    private object locker = new object();
     /// <summary>
 …
     public int ProcessedEvents { get; protected set; }
+    public Environment() : this(new DateTime(1970, 1, 1)) { }
+    public Environment(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
+    public Environment(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
+    public Environment(DateTime initialDateTime, TimeSpan? defaultStep = null) {
+    public Simulation() : this(new DateTime(1970, 1, 1)) { }
+    public Simulation(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
+    public Simulation(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
+    public Simulation(DateTime initialDateTime, TimeSpan? defaultStep = null) : this(new PcgRandom(), initialDateTime, defaultStep) { }
+    public Simulation(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) : this(new PcgRandom(randomSeed), initialDateTime, defaultStep) { }
+    public Simulation(IRandom random, DateTime initialDateTime, TimeSpan? defaultStep = null) {
       DefaultTimeStepSeconds = (defaultStep ?? TimeSpan.FromSeconds(1)).Duration().TotalSeconds;
       StartDate = initialDateTime;
       Now = initialDateTime;
+      Random = new SystemRandom();
+      ScheduleQ = new EventQueue(InitialMaxEvents);
+      Logger = Console.Out;
+    }
+    public Environment(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) {
+      DefaultTimeStepSeconds = (defaultStep ?? TimeSpan.FromSeconds(1)).Duration().TotalSeconds;
+      StartDate = initialDateTime;
+      Now = initialDateTime;
+      Random = new SystemRandom(randomSeed);
+      Random = random;
       ScheduleQ = new EventQueue(InitialMaxEvents);
       Logger = Console.Out;
 …
       ProcessedEvents = 0;
       Now = StartDate;
       Random = new SystemRandom(randomSeed);
+      Random = new PcgRandom(randomSeed);
       ScheduleQ = new EventQueue(InitialMaxEvents);
+      useSpareNormal = false;
+    }
 …
     /// </summary>
     /// <param name="event">The event that should be scheduled.</param>
     /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param></param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
     public virtual void Schedule(Event @event, int priority = 0) {
+      lock (locker) {
+        DoSchedule(Now, @event, priority);
+      }
+      DoSchedule(Now, @event, priority);
+    }
 …
       if (delay < TimeSpan.Zero)
         throw new ArgumentException("Negative delays are not allowed in Schedule(TimeSpan, Event).");
+      lock (locker) {
+        var eventTime = Now + delay;
+        DoSchedule(eventTime, @event, priority);
+      }
+      var eventTime = Now + delay;
+      DoSchedule(eventTime, @event, priority);
+    }
 …
+    }
+    protected bool _stopRequested = false;
+    /// <summary>
+    /// Run until a certain event is processed.
+    /// </summary>
+    /// <remarks>
+    /// This simulation environment is not thread-safe, thus triggering this event outside the environment
+    /// leads to potential race conditions. Please use the <see cref="ThreadSafeSimulation"/> environment in case you
+    /// require this functionality. Note that the performance of <see cref="ThreadSafeSimulation"/> is lower due to locking.
+    ///
+    /// For real-time based termination, you can also call <see cref="StopAsync"/> which sets a flag indicating the simulation
+    /// to stop before processing the next event.
+    /// </remarks>
+    /// <param name="stopEvent">The event that stops the simulation.</param>
+    /// <returns></returns>
     public virtual object Run(Event stopEvent = null) {
+      _stopRequested = false;
       if (stopEvent != null) {
         if (stopEvent.IsProcessed) return stopEvent.Value;
 …
       try {
         var stop = ScheduleQ.Count == 0;
+        var stop = ScheduleQ.Count == 0 || _stopRequested;
         while (!stop) {
           Step();
           ProcessedEvents++;
+          lock (locker) {
+            stop = ScheduleQ.Count == 0;
+          stop = ScheduleQ.Count == 0 || _stopRequested;
+        }
+      } catch (StopSimulationException e) { return e.Value; }
+      if (stopEvent == null) return null;
+      if (!stopEvent.IsTriggered) throw new InvalidOperationException("No scheduled events left but \"until\" event was not triggered.");
+      return stopEvent.Value;
+    }
+    public virtual void StopAsync() {
+      _stopRequested = true;
+    }
+    /// <summary>
+    /// Performs a single step of the simulation, i.e. process a single event
+    /// </summary>
+    /// <remarks>
+    /// This method is not thread-safe
+    /// </remarks>
+    public virtual void Step() {
+      Event evt;
+      var next = ScheduleQ.Dequeue();
+      Now = next.PrimaryPriority;
+      evt = next.Event;
+      evt.Process();
+    }
+    /// <summary>
+    /// Peeks at the time of the next event in terms of the defined step
+    /// </summary>
+    /// <remarks>
+    /// This method is not thread-safe
+    /// </remarks>
+    public virtual double PeekD() {
+      if (ScheduleQ.Count == 0) return double.MaxValue;
+      return (Peek() - StartDate).TotalSeconds / DefaultTimeStepSeconds;
+    }
+    /// <summary>
+    /// Peeks at the time of the next event
+    /// </summary>
+    /// <remarks>
+    /// This method is not thread-safe
+    /// </remarks>
+    public virtual DateTime Peek() {
+      return ScheduleQ.Count > 0 ? ScheduleQ.First.PrimaryPriority : DateTime.MaxValue;
+    }
+    protected virtual void StopSimulation(Event @event) {
+      throw new StopSimulationException(@event.Value);
+    }
+    public virtual void Log(string message, params object[] args) {
+      if (Logger != null)
+        Logger.WriteLine(message, args);
+    }
+    #region Random number distributions
+    public double RandUniform(IRandom random, double a, double b) {
+      return a + (b - a) * random.NextDouble();
+    }
+    public double RandUniform(double a, double b) {
+      return RandUniform(Random, a, b);
+    }
+    public TimeSpan RandUniform(IRandom random, TimeSpan a, TimeSpan b) {
+      return TimeSpan.FromSeconds(RandUniform(random, a.TotalSeconds, b.TotalSeconds));
+    }
+    public TimeSpan RandUniform(TimeSpan a, TimeSpan b) {
+      return RandUniform(Random, a, b);
+    }
+    public double RandTriangular(IRandom random, double low, double high) {
+      var u = random.NextDouble();
+      if (u > 0.5)
+        return high + (low - high) * Math.Sqrt(((1.0 - u) / 2));
+      return low + (high - low) * Math.Sqrt(u / 2);
+    }
+    public double RandTriangular(double low, double high) {
+      return RandTriangular(Random, low, high);
+    }
+    public TimeSpan RandTriangular(IRandom random, TimeSpan low, TimeSpan high) {
+      return TimeSpan.FromSeconds(RandTriangular(random, low.TotalSeconds, high.TotalSeconds));
+    }
+    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high) {
+      return RandTriangular(Random, low, high);
+    }
+    public double RandTriangular(IRandom random, double low, double high, double mode) {
+      var u = random.NextDouble();
+      var c = (mode - low) / (high - low);
+      if (u > c)
+        return high + (low - high) * Math.Sqrt(((1.0 - u) * (1.0 - c)));
+      return low + (high - low) * Math.Sqrt(u * c);
+    }
+    public double RandTriangular(double low, double high, double mode) {
+      return RandTriangular(Random, low, high, mode);
+    }
+    public TimeSpan RandTriangular(IRandom random, TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return TimeSpan.FromSeconds(RandTriangular(random, low.TotalSeconds, high.TotalSeconds, mode.TotalSeconds));
+    }
+    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return RandTriangular(Random, low, high, mode);
+    }
+    /// <summary>
+    /// Returns a number that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public double RandExponential(IRandom random, double mean) {
+      return -Math.Log(1 - random.NextDouble()) * mean;
+    }
+    /// <summary>
+    /// Returns a number that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public double RandExponential(double mean) {
+      return RandExponential(Random, mean);
+    }
+    /// <summary>
+    /// Returns a timespan that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public TimeSpan RandExponential(IRandom random, TimeSpan mean) {
+      return TimeSpan.FromSeconds(RandExponential(random, mean.TotalSeconds));
+    }
+    /// <summary>
+    /// Returns a timespan that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public TimeSpan RandExponential(TimeSpan mean) {
+      return RandExponential(Random, mean);
+    }
+    private bool useSpareNormal = false;
+    private double spareNormal = double.NaN;
+    /// <summary>
+    /// Uses the Marsaglia polar method to generate a random variable
+    /// from two uniform random distributed values.
+    /// </summary>
+    /// <remarks>
+    /// A spare random variable is generated from the second uniformly
+    /// distributed value. Thus, the two calls to the uniform random number
+    /// generator will be made only every second call.
+    /// </remarks>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mu">The mean of the normal distribution.</param>
+    /// <param name="sigma">The standard deviation of the normal distribution.</param>
+    /// <returns>A number that is normal distributed.</returns>
+    public virtual double RandNormal(IRandom random, double mu, double sigma) {
+      if (useSpareNormal) {
+        useSpareNormal = false;
+        return spareNormal * sigma + mu;
+      } else {
+        double u, v, s;
+        do {
+          u = random.NextDouble() * 2 - 1;
+          v = random.NextDouble() * 2 - 1;
+          s = u * u + v * v;
+        } while (s >= 1 || s == 0);
+        var mul = Math.Sqrt(-2.0 * Math.Log(s) / s);
+        spareNormal = v * mul;
+        useSpareNormal = true;
+        return mu + sigma * u * mul;
+      }
+    }
+    /// <summary>
+    /// Uses the Marsaglia polar method to generate a random variable
+    /// from two uniform random distributed values.
+    /// </summary>
+    /// <remarks>
+    /// A spare random variable is generated from the second uniformly
+    /// distributed value. Thus, the two calls to the uniform random number
+    /// generator will be made only every second call.
+    /// </remarks>
+    /// <param name="mu">The mean of the normal distribution.</param>
+    /// <param name="sigma">The standard deviation of the normal distribution.</param>
+    /// <returns>A number that is normal distributed.</returns>
+    public double RandNormal(double mu, double sigma) {
+      return RandNormal(Random, mu, sigma);
+    }
+    /// <summary>
+    /// Uses the Marsaglia polar method to generate a random variable
+    /// from two uniform random distributed values.
+    /// </summary>
+    /// <remarks>
+    /// A spare random variable is generated from the second uniformly
+    /// distributed value. Thus, the two calls to the uniform random number
+    /// generator will be made only every second call.
+    /// </remarks>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mu">The mean of the normal distribution.</param>
+    /// <param name="sigma">The standard deviation of the normal distribution.</param>
+    /// <returns>A number that is normal distributed.</returns>
+    public TimeSpan RandNormal(IRandom random, TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandNormal(random, mu.TotalSeconds, sigma.TotalSeconds));
+    }
+    /// <summary>
+    /// Uses the Marsaglia polar method to generate a random variable
+    /// from two uniform random distributed values.
+    /// </summary>
+    /// <remarks>
+    /// A spare random variable is generated from the second uniformly
+    /// distributed value. Thus, the two calls to the uniform random number
+    /// generator will be made only every second call.
+    /// </remarks>
+    /// <param name="mu">The mean of the normal distribution.</param>
+    /// <param name="sigma">The standard deviation of the normal distribution.</param>
+    /// <returns>A number that is normal distributed.</returns>
+    public TimeSpan RandNormal(TimeSpan mu, TimeSpan sigma) {
+      return RandNormal(Random, mu, sigma);
+    }
+    public double RandNormalPositive(IRandom random, double mu, double sigma) {
+      double val;
+      do {
+        val = RandNormal(random, mu, sigma);
+      } while (val <= 0);
+      return val;
+    }
+    public double RandNormalPositive(double mu, double sigma) {
+      return RandNormalPositive(Random, mu, sigma);
+    }
+    public TimeSpan RandNormalPositive(IRandom random, TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandNormalPositive(random, mu.TotalSeconds, sigma.TotalSeconds));
+    }
+    public TimeSpan RandNormalPositive(TimeSpan mu, TimeSpan sigma) {
+      return RandNormalPositive(Random, mu, sigma);
+    }
+    public double RandNormalNegative(IRandom random, double mu, double sigma) {
+      double val;
+      do {
+        val = RandNormal(random, mu, sigma);
+      } while (val >= 0);
+      return val;
+    }
+    public double RandNormalNegative(double mu, double sigma) {
+      return RandNormalNegative(Random, mu, sigma);
+    }
+    public TimeSpan RandNormalNegative(IRandom random, TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandNormalNegative(random, mu.TotalSeconds, sigma.TotalSeconds));
+    }
+    public TimeSpan RandNormalNegative(TimeSpan mu, TimeSpan sigma) {
+      return RandNormalNegative(Random, mu, sigma);
+    }
+    /// <summary>
+    /// Returns values from a log-normal distribution with the mean
+    /// exp(mu + sigma^2 / 2)
+    /// and the standard deviation
+    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
+    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
+    /// <returns>A log-normal distributed random value.</returns>
+    public double RandLogNormal(IRandom random, double mu, double sigma) {
+      return Math.Exp(RandNormal(random, mu, sigma));
+    }
+    /// <summary>
+    /// Returns values from a log-normal distribution with the mean
+    /// exp(mu + sigma^2 / 2)
+    /// and the standard deviation
+    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
+    /// </summary>
+    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
+    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
+    /// <returns>A log-normal distributed random value.</returns>
+    public double RandLogNormal(double mu, double sigma) {
+      return RandLogNormal(Random, mu, sigma);
+    }
+    /// <summary>
+    /// Returns values from a log-normal distribution with
+    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mean">The distribution mean.</param>
+    /// <param name="stdev">The distribution standard deviation.</param>
+    /// <returns>A log-normal distributed random value.</returns>
+    public double RandLogNormal2(IRandom random, double mean, double stdev) {
+      if (stdev == 0) return mean;
+      var alpha = Math.Sqrt(mean * stdev) / mean;
+      var sigma = Math.Sqrt(Math.Log(1 + (alpha * alpha)));
+      var mu = Math.Log(mean) - 0.5 * sigma * sigma;
+      return Math.Exp(RandNormal(random, mu, sigma));
+    }
+    /// <summary>
+    /// Returns values from a log-normal distribution with
+    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
+    /// </summary>
+    /// <param name="mean">The distribution mean.</param>
+    /// <param name="stdev">The distribution standard deviation.</param>
+    /// <returns>A log-normal distributed random value.</returns>
+    public double RandLogNormal2(double mean, double stdev) {
+      return RandLogNormal2(Random, mean, stdev);
+    }
+    /// <summary>
+    /// Returns a timespan value from a log-normal distribution with the mean
+    /// exp(mu + sigma^2 / 2)
+    /// and the standard deviation
+    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
+    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
+    /// <returns>A log-normal distributed random timespan.</returns>
+    public TimeSpan RandLogNormal(IRandom random, TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandLogNormal(random, mu.TotalSeconds, sigma.TotalSeconds));
+    }
+    /// <summary>
+    /// Returns a timespan value from a log-normal distribution with the mean
+    /// exp(mu + sigma^2 / 2)
+    /// and the standard deviation
+    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
+    /// </summary>
+    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
+    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
+    /// <returns>A log-normal distributed random timespan.</returns>
+    public TimeSpan RandLogNormal(TimeSpan mu, TimeSpan sigma) {
+      return RandLogNormal(Random, mu, sigma);
+    }
+    /// <summary>
+    /// Returns a timespan value from a log-normal distribution with
+    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="mean">The distribution mean.</param>
+    /// <param name="stdev">The distribution standard deviation.</param>
+    /// <returns>A log-normal distributed random timespan.</returns>
+    public TimeSpan RandLogNormal2(IRandom random, TimeSpan mean, TimeSpan stdev) {
+      return TimeSpan.FromSeconds(RandLogNormal2(random, mean.TotalSeconds, stdev.TotalSeconds));
+    }
+    /// <summary>
+    /// Returns a timespan value from a log-normal distribution with
+    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
+    /// </summary>
+    /// <param name="mean">The distribution mean.</param>
+    /// <param name="stdev">The distribution standard deviation.</param>
+    /// <returns>A log-normal distributed random timespan.</returns>
+    public TimeSpan RandLogNormal2(TimeSpan mean, TimeSpan stdev) {
+      return RandLogNormal2(Random, mean, stdev);
+    }
+    public double RandCauchy(IRandom random, double x0, double gamma) {
+      return x0 + gamma * Math.Tan(Math.PI * (random.NextDouble() - 0.5));
+    }
+    public double RandCauchy(double x0, double gamma) {
+      return RandCauchy(Random, x0, gamma);
+    }
+    public TimeSpan RandCauchy(IRandom random, TimeSpan x0, TimeSpan gamma) {
+      return TimeSpan.FromSeconds(RandCauchy(random, x0.TotalSeconds, gamma.TotalSeconds));
+    }
+    public TimeSpan RandCauchy(TimeSpan x0, TimeSpan gamma) {
+      return RandCauchy(Random, x0, gamma);
+    }
+    public double RandWeibull(IRandom random, double alpha, double beta) {
+      return alpha * Math.Pow(-Math.Log(1 - random.NextDouble()), 1 / beta);
+    }
+    public double RandWeibull(double alpha, double beta) {
+      return RandWeibull(Random, alpha, beta);
+    }
+    public TimeSpan RandWeibull(IRandom random, TimeSpan alpha, TimeSpan beta) {
+      return TimeSpan.FromSeconds(RandWeibull(random, alpha.TotalSeconds, beta.TotalSeconds));
+    }
+    public TimeSpan RandWeibull(TimeSpan alpha, TimeSpan beta) {
+      return RandWeibull(Random, alpha, beta);
+    }
+    #endregion
+    #region Random timeouts
+    public Timeout TimeoutUniformD(IRandom random, double a, double b) {
+      return new Timeout(this, ToTimeSpan(RandUniform(random, a, b)));
+    }
+    public Timeout TimeoutUniformD(double a, double b) {
+      return TimeoutUniformD(Random, a, b);
+    }
+    public Timeout TimeoutUniform(IRandom random, TimeSpan a, TimeSpan b) {
+      return new Timeout(this, RandUniform(random, a, b));
+    }
+    public Timeout TimeoutUniform(TimeSpan a, TimeSpan b) {
+      return TimeoutUniform(Random, a, b);
+    }
+    public Timeout TimeoutTriangularD(IRandom random, double low, double high) {
+      return new Timeout(this, ToTimeSpan(RandTriangular(random, low, high)));
+    }
+    public Timeout TimeoutTriangularD(double low, double high) {
+      return TimeoutTriangularD(Random, low, high);
+    }
+    public Timeout TimeoutTriangular(IRandom random, TimeSpan low, TimeSpan high) {
+      return new Timeout(this, RandTriangular(random, low, high));
+    }
+    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high) {
+      return TimeoutTriangular(Random, low, high);
+    }
+    public Timeout TimeoutTriangularD(IRandom random, double low, double high, double mode) {
+      return new Timeout(this, ToTimeSpan(RandTriangular(random, low, high, mode)));
+    }
+    public Timeout TimeoutTriangularD(double low, double high, double mode) {
+      return TimeoutTriangularD(Random, low, high, mode);
+    }
+    public Timeout TimeoutTriangular(IRandom random, TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return new Timeout(this, RandTriangular(random, low, high, mode));
+    }
+    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return TimeoutTriangular(Random, low, high, mode);
+    }
+    public Timeout TimeoutExponentialD(IRandom random, double mean) {
+      return new Timeout(this, ToTimeSpan(RandExponential(random, mean)));
+    }
+    public Timeout TimeoutExponentialD(double mean) {
+      return TimeoutExponentialD(Random, mean);
+    }
+    public Timeout TimeoutExponential(IRandom random, TimeSpan mean) {
+      return new Timeout(this, RandExponential(random, mean));
+    }
+    public Timeout TimeoutExponential(TimeSpan mean) {
+      return TimeoutExponential(Random, mean);
+    }
+    public Timeout TimeoutNormalPositiveD(IRandom random, double mu, double sigma) {
+      return new Timeout(this, ToTimeSpan(RandNormalPositive(random, mu, sigma)));
+    }
+    public Timeout TimeoutNormalPositiveD(double mu, double sigma) {
+      return TimeoutNormalPositiveD(Random, mu, sigma);
+    }
+    public Timeout TimeoutNormalPositive(IRandom random, TimeSpan mu, TimeSpan sigma) {
+      return new Timeout(this, RandNormalPositive(random, mu, sigma));
+    }
+    public Timeout TimeoutNormalPositive(TimeSpan mu, TimeSpan sigma) {
+      return TimeoutNormalPositive(Random, mu, sigma);
+    }
+    public Timeout TimeoutLogNormalD(IRandom random, double mu, double sigma) {
+      return new Timeout(this, ToTimeSpan(RandLogNormal(random, mu, sigma)));
+    }
+    public Timeout TimeoutLogNormalD(double mu, double sigma) {
+      return TimeoutLogNormalD(Random, mu, sigma);
+    }
+    public Timeout TimeoutLogNormal2D(IRandom random, double mean, double stdev) {
+      return new Timeout(this, ToTimeSpan(RandLogNormal2(random, mean, stdev)));
+    }
+    public Timeout TimeoutLogNormal2D(double mean, double stdev) {
+      return TimeoutLogNormal2D(Random, mean, stdev);
+    }
+    public Timeout TimeoutLogNormal(IRandom random, TimeSpan mu, TimeSpan sigma) {
+      return new Timeout(this, RandLogNormal(random, mu, sigma));
+    }
+    public Timeout TimeoutLogNormal(TimeSpan mu, TimeSpan sigma) {
+      return TimeoutLogNormal(Random, mu, sigma);
+    }
+    public Timeout TimeoutLogNormal2(IRandom random, TimeSpan mean, TimeSpan stdev) {
+      return new Timeout(this, RandLogNormal2(random, mean, stdev));
+    }
+    public Timeout TimeoutLogNormal2(TimeSpan mean, TimeSpan stdev) {
+      return TimeoutLogNormal2(Random, mean, stdev);
+    }
+    #endregion
+  }
+  /// <summary>
+  /// Provides a simulation environment that is thread-safe against manipulations of the event queue.
+  /// Its performance is somewhat lower than the non-thread-safe environment (cf. <see cref="Simulation"/>)
+  /// due to the locking involved.
+  /// </summary>
+  /// <remarks>
+  /// Please carefully consider if you must really schedule the stop event in a separate thread. You can also
+  /// call <see cref="Simulation.StopAsync"/> to request termination after the current event has been processed.
+  ///
+  /// The simulation will still run in only one thread and execute all events sequentially.
+  /// </remarks>
+  public class ThreadSafeSimulation : Simulation {
+    protected object _locker;
+    public ThreadSafeSimulation() : this(new DateTime(1970, 1, 1)) { }
+    public ThreadSafeSimulation(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
+    public ThreadSafeSimulation(DateTime initialDateTime, TimeSpan? defaultStep = null) : this(new PcgRandom(), initialDateTime, defaultStep) { }
+    public ThreadSafeSimulation(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
+    public ThreadSafeSimulation(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) : this(new PcgRandom(randomSeed), initialDateTime, defaultStep) { }
+    public ThreadSafeSimulation(IRandom random, DateTime initialDateTime, TimeSpan? defaultStep = null) : base(random, initialDateTime, defaultStep) {
+      _locker = new object();
+    }
+    /// <summary>
+    /// Schedules an event to occur at the same simulation time as the call was made.
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe against manipulations of the event queue
+    /// </remarks>
+    /// <param name="event">The event that should be scheduled.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public override void Schedule(Event @event, int priority = 0) {
+      lock (_locker) {
+        DoSchedule(Now, @event, priority);
+      }
+    }
+    /// <summary>
+    /// Schedules an event to occur after a certain (positive) delay.
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe against manipulations of the event queue
+    /// </remarks>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="delay"/> is negative.
+    /// </exception>
+    /// <param name="delay">The (positive) delay after which the event should be fired.</param>
+    /// <param name="event">The event that should be scheduled.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public override void Schedule(TimeSpan delay, Event @event, int priority = 0) {
+      if (delay < TimeSpan.Zero)
+        throw new ArgumentException("Negative delays are not allowed in Schedule(TimeSpan, Event).");
+      lock (_locker) {
+        var eventTime = Now + delay;
+        DoSchedule(eventTime, @event, priority);
+      }
+    }
+    /// <summary>
+    /// Run until a certain event is processed.
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe against manipulations of the event queue
+    /// </remarks>
+    /// <param name="stopEvent">The event that stops the simulation.</param>
+    /// <returns></returns>
+    public override object Run(Event stopEvent = null) {
+      _stopRequested = false;
+      if (stopEvent != null) {
+        if (stopEvent.IsProcessed) return stopEvent.Value;
+        stopEvent.AddCallback(StopSimulation);
+      }
+      try {
+        var stop = false;
+        lock (_locker) {
+          stop = ScheduleQ.Count == 0 || _stopRequested;
+        }
+        while (!stop) {
+          Step();
+          ProcessedEvents++;
+          lock (_locker) {
+            stop = ScheduleQ.Count == 0 || _stopRequested;
+          }
+        }
 …
+    }
+    public virtual void Step() {
+    /// <summary>
+    /// Performs a single step of the simulation, i.e. process a single event
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe against manipulations of the event queue
+    /// </remarks>
+    public override void Step() {
       Event evt;
       lock (locker) {
+      lock (_locker) {
         var next = ScheduleQ.Dequeue();
         Now = next.PrimaryPriority;
 …
+    }
+    public virtual double PeekD() {
+      lock (locker) {
+    /// <summary>
+    /// Peeks at the time of the next event in terms of the defined step
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe against manipulations of the event queue
+    /// </remarks>
+    public override double PeekD() {
+      lock (_locker) {
         if (ScheduleQ.Count == 0) return double.MaxValue;
         return (Peek() - StartDate).TotalSeconds / DefaultTimeStepSeconds;
 …
+    }
+    public virtual DateTime Peek() {
+      lock (locker) {
+    /// <summary>
+    /// Peeks at the time of the next event
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe against manipulations of the event queue
+    /// </remarks>
+    public override DateTime Peek() {
+      lock (_locker) {
         return ScheduleQ.Count > 0 ? ScheduleQ.First.PrimaryPriority : DateTime.MaxValue;
+      }
+    }
+    protected virtual void StopSimulation(Event @event) {
+      throw new StopSimulationException(@event.Value);
+    }
+    public virtual void Log(string message, params object[] args) {
+      if (Logger != null)
+        Logger.WriteLine(message, args);
+    }
+    #region Random number distributions
+  }
+  /// <summary>
+  /// Environments hold the event queues, schedule and process events.
+  /// </summary>
+  [Obsolete("Use class Simulation or ThreadSafeSimulation instead. Due to name clashes with System.Environment the class SimSharp.Environment is being outphased.")]
+  public class Environment : ThreadSafeSimulation {
+    public Environment()
+      : base() {
+      Random = new SystemRandom();
+    }
+    public Environment(TimeSpan? defaultStep)
+      : base(defaultStep) {
+      Random = new SystemRandom();
+    }
+    public Environment(int randomSeed, TimeSpan? defaultStep = null)
+      : base(randomSeed, defaultStep) {
+      Random = new SystemRandom(randomSeed);
+    }
+    public Environment(DateTime initialDateTime, TimeSpan? defaultStep = null)
+      : base(initialDateTime, defaultStep) {
+      Random = new SystemRandom();
+    }
+    public Environment(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null)
+      : base(initialDateTime, randomSeed, defaultStep) {
+      Random = new SystemRandom(randomSeed);
+    }
     protected static readonly double NormalMagicConst = 4 * Math.Exp(-0.5) / Math.Sqrt(2.0);
+    public double RandUniform(double a, double b) {
+      return a + (b - a) * Random.NextDouble();
+    }
+    public TimeSpan RandUniform(TimeSpan a, TimeSpan b) {
+      return TimeSpan.FromSeconds(RandUniform(a.TotalSeconds, b.TotalSeconds));
+    }
+    public double RandTriangular(double low, double high) {
+      var u = Random.NextDouble();
+      if (u > 0.5)
+        return high + (low - high) * Math.Sqrt(((1.0 - u) / 2));
+      return low + (high - low) * Math.Sqrt(u / 2);
+    }
+    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high) {
+      return TimeSpan.FromSeconds(RandTriangular(low.TotalSeconds, high.TotalSeconds));
+    }
+    public double RandTriangular(double low, double high, double mode) {
+      var u = Random.NextDouble();
+      var c = (mode - low) / (high - low);
+      if (u > c)
+        return high + (low - high) * Math.Sqrt(((1.0 - u) * (1.0 - c)));
+      return low + (high - low) * Math.Sqrt(u * c);
+    }
+    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return TimeSpan.FromSeconds(RandTriangular(low.TotalSeconds, high.TotalSeconds, mode.TotalSeconds));
+    }
+    /// <summary>
+    /// Returns a number that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public double RandExponential(double mean) {
+      return -Math.Log(1 - Random.NextDouble()) * mean;
+    }
+    /// <summary>
+    /// Returns a timespan that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public TimeSpan RandExponential(TimeSpan mean) {
+      return TimeSpan.FromSeconds(RandExponential(mean.TotalSeconds));
+    }
+    public double RandNormal(double mu, double sigma) {
+    public override double RandNormal(IRandom random, double mu, double sigma) {
       double z, zz, u1, u2;
       do {
         u1 = Random.NextDouble();
         u2 = 1 - Random.NextDouble();
+        u1 = random.NextDouble();
+        u2 = 1 - random.NextDouble();
         z = NormalMagicConst * (u1 - 0.5) / u2;
         zz = z * z / 4.0;
 …
       return mu + z * sigma;
+    }
-    public TimeSpan RandNormal(TimeSpan mu, TimeSpan sigma) {
-      return TimeSpan.FromSeconds(RandNormal(mu.TotalSeconds, sigma.TotalSeconds));
+    }
-    public double RandNormalPositive(double mu, double sigma) {
-      double val;
-      do {
-        val = RandNormal(mu, sigma);
-      } while (val <= 0);
-      return val;
+    }
-    public TimeSpan RandNormalPositive(TimeSpan mu, TimeSpan sigma) {
-      return TimeSpan.FromSeconds(RandNormalPositive(mu.TotalSeconds, sigma.TotalSeconds));
+    }
-    public double RandNormalNegative(double mu, double sigma) {
-      double val;
-      do {
-        val = RandNormal(mu, sigma);
-      } while (val >= 0);
-      return val;
+    }
-    public TimeSpan RandNormalNegative(TimeSpan mu, TimeSpan sigma) {
-      return TimeSpan.FromSeconds(RandNormalNegative(mu.TotalSeconds, sigma.TotalSeconds));
+    }
-    public double RandLogNormal(double mu, double sigma) {
-      return Math.Exp(RandNormal(mu, sigma));
+    }
-    public TimeSpan RandLogNormal(TimeSpan mu, TimeSpan sigma) {
-      return TimeSpan.FromSeconds(RandLogNormal(mu.TotalSeconds, sigma.TotalSeconds));
+    }
-    public double RandCauchy(double x0, double gamma) {
-      return x0 + gamma * Math.Tan(Math.PI * (Random.NextDouble() - 0.5));
+    }
-    public TimeSpan RandCauchy(TimeSpan x0, TimeSpan gamma) {
-      return TimeSpan.FromSeconds(RandCauchy(x0.TotalSeconds, gamma.TotalSeconds));
+    }
-    public double RandWeibull(double alpha, double beta) {
-      return alpha * Math.Pow(-Math.Log(1 - Random.NextDouble()), 1 / beta);
+    }
-    public TimeSpan RandWeibull(TimeSpan mu, TimeSpan sigma) {
-      return TimeSpan.FromSeconds(RandWeibull(mu.TotalSeconds, sigma.TotalSeconds));
+    }
-    #endregion
-    #region Random timeouts
-    public Timeout TimeoutUniformD(double a, double b) {
-      return new Timeout(this, ToTimeSpan(RandUniform(a, b)));
+    }
-    public Timeout TimeoutUniform(TimeSpan a, TimeSpan b) {
-      return new Timeout(this, RandUniform(a, b));
+    }
-    public Timeout TimeoutTriangularD(double low, double high) {
-      return new Timeout(this, ToTimeSpan(RandTriangular(low, high)));
+    }
-    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high) {
-      return new Timeout(this, RandTriangular(low, high));
+    }
-    public Timeout TimeoutTriangularD(double low, double high, double mode) {
-      return new Timeout(this, ToTimeSpan(RandTriangular(low, high, mode)));
+    }
-    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
-      return new Timeout(this, RandTriangular(low, high, mode));
+    }
-    public Timeout TimeoutExponentialD(double mean) {
-      return new Timeout(this, ToTimeSpan(RandExponential(mean)));
+    }
-    public Timeout TimeoutExponential(TimeSpan mean) {
-      return new Timeout(this, RandExponential(mean));
+    }
-    public Timeout TimeoutNormalPositiveD(double mu, double sigma) {
-      return new Timeout(this, ToTimeSpan(RandNormalPositive(mu, sigma)));
+    }
-    public Timeout TimeoutNormalPositive(TimeSpan mu, TimeSpan sigma) {
-      return new Timeout(this, RandNormalPositive(mu, sigma));
+    }
-    public Timeout TimeoutLogNormalD(double mu, double sigma) {
-      return new Timeout(this, ToTimeSpan(RandLogNormal(mu, sigma)));
+    }
-    public Timeout TimeoutLogNormal(TimeSpan mu, TimeSpan sigma) {
-      return new Timeout(this, RandLogNormal(mu, sigma));
+    }
-    #endregion
+  }
+}

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/AllOf.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
   public class AllOf : Condition {
     public AllOf(Environment environment, params Event[] events) : base(environment, events) { }
     public AllOf(Environment environment, IEnumerable<Event> events) : base(environment, events) { }
+    public AllOf(Simulation environment, params Event[] events) : base(environment, events) { }
+    public AllOf(Simulation environment, IEnumerable<Event> events) : base(environment, events) { }
     protected override bool Evaluate() {

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/AnyOf.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
   public class AnyOf : Condition {
     public AnyOf(Environment environment, params Event[] events) : base(environment, events) { }
     public AnyOf(Environment environment, IEnumerable<Event> events) : base(environment, events) { }
+    public AnyOf(Simulation environment, params Event[] events) : base(environment, events) { }
+    public AnyOf(Simulation environment, IEnumerable<Event> events) : base(environment, events) { }
     protected override bool Evaluate() {

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Condition.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     protected List<Event> FiredEvents { get; private set; }
     protected Condition(Environment environment, params Event[] events)
+    protected Condition(Simulation environment, params Event[] events)
       : this(environment, (IEnumerable<Event>)events) { }
     protected Condition(Environment environment, IEnumerable<Event> events)
+    protected Condition(Simulation environment, IEnumerable<Event> events)
       : base(environment) {
       CallbackList.Add(CollectValues);

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Event.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
   /// </summary>
   public class Event {
     protected internal Environment Environment { get; private set; }
+    protected internal Simulation Environment { get; private set; }
     protected List<Action<Event>> CallbackList { get; set; }
 …
     public bool IsTriggered { get; protected set; }
     public Event(Environment environment) {
+    public Event(Simulation environment) {
       Environment = environment;
       CallbackList = new List<Action<Event>>();
 …
       if (IsProcessed) throw new InvalidOperationException("Event has already been processed.");
       IsProcessed = true;
       foreach (var callback in CallbackList)
         callback(this);
+      for (var i = 0; i < CallbackList.Count; i++)
+        CallbackList[i](this);
       CallbackList = null;
+    }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Process.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     /// <param name="generator">The generator function of the process.</param>
     /// <param name="priority">The priority if multiple processes are started at the same time.</param>
     public Process(Environment environment, IEnumerable<Event> generator, int priority = 0)
+    public Process(Simulation environment, IEnumerable<Event> generator, int priority = 0)
       : base(environment) {
       this.generator = generator.GetEnumerator();
 …
       Environment.ActiveProcess = null;
+    }
     protected virtual bool ProceedToEvent() {
       target = generator.Current;
 …
     private class Initialize : Event {
       public Initialize(Environment environment, Process process, int priority)
+      public Initialize(Simulation environment, Process process, int priority)
         : base(environment) {
         CallbackList.Add(process.Resume);

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Timeout.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     /// <param name="isOk">Whether the timeout should succeed or fail.</param>
     /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
     public Timeout(Environment environment, TimeSpan delay, object value = null, bool isOk = true, int priority = 0)
+    public Timeout(Simulation environment, TimeSpan delay, object value = null, bool isOk = true, int priority = 0)
       : base(environment) {
       IsOk = isOk;

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Exceptions/EmptyScheduleException.cs

r15972	r17053
1	1	#region License Information
2	2	/* SimSharp - A .NET port of SimPy, discrete event simulation framework
3		Copyright (C) 2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
	3	Copyright (C) 2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4	4
5	5	This program is free software: you can redistribute it and/or modify

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Preempted.cs

r15972	r17053
1	1	#region License Information
2	2	/* SimSharp - A .NET port of SimPy, discrete event simulation framework
3		Copyright (C) 2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
	3	Copyright (C) 2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4	4
5	5	This program is free software: you can redistribute it and/or modify

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Container.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 using System;
 using System.Collections.Generic;
-using System.Linq;
 namespace SimSharp {
+  /// <summary>
+  /// A container holds a variable amount of a single continuous entity, e.g. water, coal, grain, etc.
+  ///
+  /// Put and Get are in FIFO order only when they can be satisfied.
+  /// Any put or get that can be satisfied takes precedence.
+  /// Put events that attempt to add more to the Container than there is capacity for and
+  /// Get events that remove more than there is are backlogged.
+  /// </summary>
   public class Container {
+    public double Capacity { get; protected set; }
     public double Level { get; protected set; }
+    public double Capacity { get; protected set; }
     protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
     protected Queue<ContainerPut> PutQueue { get; private set; }
     protected Queue<ContainerGet> GetQueue { get; private set; }
+    protected SimplePriorityQueue<Event, double> WhenAtLeastQueue { get; private set; }
+    protected SimplePriorityQueue<Event, double> WhenAtMostQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
     public Container(Environment environment, double capacity = double.MaxValue, double initial = 0) {
+    public Container(Simulation environment, double capacity = double.MaxValue, double initial = 0) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
       if (initial < 0) throw new ArgumentException("Initial must be >= 0", "initial");
 …
       PutQueue = new Queue<ContainerPut>();
       GetQueue = new Queue<ContainerGet>();
+      WhenAtLeastQueue = new SimplePriorityQueue<Event, double>();
+      WhenAtMostQueue = new SimplePriorityQueue<Event, double>(new ReverseComparer<double>());
+      WhenChangeQueue = new List<Event>();
+    }
 …
       TriggerGet();
       return get;
+    }
+    public virtual Event WhenAtLeast(double level) {
+      var whenAtLeast = new Event(Environment);
+      WhenAtLeastQueue.Enqueue(whenAtLeast, level);
+      TriggerWhenAtLeast();
+      return whenAtLeast;
+    }
+    public virtual Event WhenFull() {
+      return WhenAtLeast(Capacity);
+    }
+    public virtual Event WhenAtMost(double level) {
+      var whenAtMost = new Event(Environment);
+      WhenAtMostQueue.Enqueue(whenAtMost, level);
+      TriggerWhenAtMost();
+      return whenAtMost;
+    }
+    public virtual Event WhenEmpty() {
+      return WhenAtMost(0);
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
 …
         if (put.IsTriggered) {
           PutQueue.Dequeue();
+          TriggerWhenAtLeast();
+          TriggerWhenChange();
         } else break;
+      }
 …
         if (get.IsTriggered) {
           GetQueue.Dequeue();
+          TriggerWhenAtMost();
+          TriggerWhenChange();
         } else break;
+      }
+    }
+    protected virtual void TriggerWhenAtLeast() {
+      while (WhenAtLeastQueue.Count > 0 && Level >= WhenAtLeastQueue.Peek) {
+        var whenAtLeast = WhenAtLeastQueue.Dequeue();
+        whenAtLeast.Succeed();
+      }
+    }
+    protected virtual void TriggerWhenAtMost() {
+      while (WhenAtMostQueue.Count > 0 && Level <= WhenAtMostQueue.Peek) {
+        var whenAtMost = WhenAtMostQueue.Dequeue();
+        whenAtMost.Succeed();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }
+}

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/ContainerGet.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     public double Amount { get; protected set; }
     public DateTime Time { get; private set; }
     public Process Process { get; private set; }
+    public Process Owner { get; set; }
     public ContainerGet(Environment environment, Action<Event> callback, double amount)
+    public ContainerGet(Simulation environment, Action<Event> callback, double amount)
       : base(environment) {
       if (amount <= 0) throw new ArgumentException("Amount must be > 0.", "amount");
 …
       CallbackList.Add(callback);
       Time = environment.Now;
       Process = environment.ActiveProcess;
+      Owner = environment.ActiveProcess;
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/ContainerPut.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     public double Amount { get; protected set; }
     public DateTime Time { get; private set; }
     public Process Process { get; private set; }
+    public Process Owner { get; set; }
     public ContainerPut(Environment environment, Action<Event> callback, double amount)
+    public ContainerPut(Simulation environment, Action<Event> callback, double amount)
       : base(environment) {
       if (amount <= 0) throw new ArgumentException("Amount must be > 0.", "amount");
 …
       CallbackList.Add(callback);
       Time = environment.Now;
       Process = environment.ActiveProcess;
+      Owner = environment.ActiveProcess;
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/FilterStoreGet.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     public Func<object, bool> Filter { get; private set; }
     public FilterStoreGet(Environment environment, Action<Event> callback, Func<object, bool> filter)
+    public FilterStoreGet(Simulation environment, Action<Event> callback, Func<object, bool> filter)
       : base(environment, callback) {
       Filter = filter;

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/PreemptiveRequest.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
+  public sealed class PreemptiveRequest : PriorityRequest {
+  public sealed class PreemptiveRequest : Request, IComparable<PreemptiveRequest>, IComparable {
+    public double Priority { get; private set; }
     public bool Preempt { get; private set; }
+    public bool IsPreempted { get; internal set; }
+    public PreemptiveRequest(Environment environment, Action<Event> callback, Action<Event> disposeCallback, int priority = 1, bool preempt = false)
+      : base(environment, callback, disposeCallback, priority) {
+    public PreemptiveRequest(Simulation environment, Action<Event> callback, Action<Event> disposeCallback, double priority = 1, bool preempt = false)
+      : base(environment, callback, disposeCallback) {
+      Priority = priority;
       Preempt = preempt;
+    }
+    public int CompareTo(PreemptiveRequest other) {
+      if (Priority > other.Priority) return 1;
+      else if (Priority < other.Priority) return -1;
+      if (Time > other.Time) return 1;
+      else if (Time < other.Time) return -1;
+      if (!Preempt && other.Preempt) return 1;
+      else if (Preempt && !other.Preempt) return -1;
+      return 0;
+    }
+    public int CompareTo(object obj) {
+      if (obj is PreemptiveRequest other) return CompareTo(other);
+      if (obj == null) return 1;
+      throw new ArgumentException("Can only compare to other objects of type PreemptiveRequest");
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/Release.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     public Request Request { get; private set; }
     public Release(Environment environment, Request request, Action<Event> callback)
+    public Release(Simulation environment, Request request, Action<Event> callback)
       : base(environment) {
       Request = request;

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/Request.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     private readonly Action<Event> disposeCallback;
     public DateTime Time { get; private set; }
     public Process Process { get; private set; }
+    public Process Owner { get; set; }
     public Request(Environment environment, Action<Event> callback, Action<Event> disposeCallback)
+    public Request(Simulation environment, Action<Event> callback, Action<Event> disposeCallback)
       : base(environment) {
       CallbackList.Add(callback);
       this.disposeCallback = disposeCallback;
       Time = environment.Now;
       Process = environment.ActiveProcess;
+      Owner = environment.ActiveProcess;
+    }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/ResourcePoolRequest.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
     public Func<object, bool> Filter { get; private set; }
     public ResourcePoolRequest(Environment environment, Action<Event> callback, Action<Event> disposeCallback, Func<object, bool> filter)
+    public ResourcePoolRequest(Simulation environment, Action<Event> callback, Action<Event> disposeCallback, Func<object, bool> filter)
       : base(environment, callback, disposeCallback) {
       Filter = filter;

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/StoreGet.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
   public class StoreGet : Event {
     public DateTime Time { get; private set; }
     public Process Process { get; private set; }
+    public Process Owner { get; set; }
     public StoreGet(Environment environment, Action<Event> callback)
+    public StoreGet(Simulation environment, Action<Event> callback)
       : base(environment) {
       CallbackList.Add(callback);
       Time = environment.Now;
       Process = environment.ActiveProcess;
+      Owner = environment.ActiveProcess;
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/StorePut.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
   public class StorePut : Event {
     public DateTime Time { get; private set; }
     public Process Process { get; private set; }
+    public Process Owner { get; set; }
     public StorePut(Environment environment, Action<Event> callback, object value)
+    public StorePut(Simulation environment, Action<Event> callback, object value)
       : base(environment) {
       if (value == null) throw new ArgumentNullException("value", "Value to put in a Store cannot be null.");
 …
       Value = value;
       Time = environment.Now;
       Process = environment.ActiveProcess;
+      Owner = environment.ActiveProcess;
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/FilterStore.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
+  /// <summary>
+  /// A filter store is similar to a <see cref="Store"/>.
+  /// However, in Get it is possible to specify the property of the item wished to retrieve.
+  ///
+  /// FilterStore holds a variable number of individual items.
+  /// Put are always performed in FIFO order.
+  /// Get are performed in FIFO order only when they match at least one item in the store.
+  /// </summary>
   public class FilterStore {
+    protected static readonly Func<object, bool> TrueFunc = _ => true;
+    public int Capacity { get; protected set; }
     public int Count { get { return Items.Count; } }
+    public int Capacity { get; protected set; }
     protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
     protected Queue<StorePut> PutQueue { get; private set; }
     protected LinkedList<FilterStoreGet> GetQueue { get; private set; }
     protected List<object> Items { get; private set; }
+    public FilterStore(Environment environment, int capacity = int.MaxValue) {
+    protected List<Event> WhenNewQueue { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
+    public FilterStore(Simulation environment, int capacity = int.MaxValue) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
       Environment = environment;
 …
       GetQueue = new LinkedList<FilterStoreGet>();
       Items = new List<object>();
+    }
+    public FilterStore(Environment environment, IEnumerable<object> items, int capacity = int.MaxValue) {
+      WhenNewQueue = new List<Event>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
+    public FilterStore(Simulation environment, IEnumerable<object> items, int capacity = int.MaxValue) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
       Environment = environment;
 …
       GetQueue = new LinkedList<FilterStoreGet>();
       Items = new List<object>(items);
+      WhenNewQueue = new List<Event>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
       if (capacity < Items.Count) throw new ArgumentException("There are more initial items than there is capacity.", "items");
+    }
 …
     public virtual FilterStoreGet Get(Func<object, bool> filter = null) {
+      if (filter == null) filter = _ => true;
+      var get = new FilterStoreGet(Environment, TriggerPut, filter);
+      var get = new FilterStoreGet(Environment, TriggerPut, filter ?? TrueFunc);
       GetQueue.AddLast(get);
       TriggerGet();
       return get;
+    }
+    public virtual Event WhenNew() {
+      var whenNew = new Event(Environment);
+      WhenNewQueue.Add(whenNew);
+      return whenNew;
+    }
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
 …
         if (put.IsTriggered) {
           PutQueue.Dequeue();
+          TriggerWhenNew();
+          TriggerWhenAny();
+          TriggerWhenFull();
+          TriggerWhenChange();
         } else break;
+      }
 …
           GetQueue.Remove(current);
           current = next;
+          TriggerWhenEmpty();
+          TriggerWhenChange();
         } else current = current.Next;
         if (Items.Count == 0) break;
+      }
+    }
+    protected virtual void TriggerWhenNew() {
+      if (WhenNewQueue.Count == 0) return;
+      foreach (var evt in WhenNewQueue)
+        evt.Succeed();
+      WhenNewQueue.Clear();
+    }
+    protected virtual void TriggerWhenAny() {
+      if (Items.Count > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenFull() {
+      if (Count == Capacity) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenEmpty() {
+      if (Count == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }
+}

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PreemptiveResource.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
+  /// <summary>
+  /// A PreemptiveResource is similar to a <see cref="PriorityResource"/>. However,
+  /// it may be possible to interrupt a lower-priority user and hand over the resource.
+  ///
+  /// PreemptiveResource holds a fixed amount of anonymous entities.
+  /// Requests are processed in this order: priority, time, preemption, and finally FIFO.
+  /// Releases are processed in FIFO order (usually no simulation time passes for a Release).
+  /// </summary>
+  /// <remarks>
+  /// Working with PreemptiveResource, a process holding a request must always call
+  /// <see cref="Process.HandleFault"/> after yielding an event and handle a potential
+  /// interruption.
+  /// </remarks>
   public class PreemptiveResource {
 …
     public int Remaining { get { return Capacity - InUse; } }
     protected Environment Environment { get; private set; }
     protected SortedList<int, LinkedList<PreemptiveRequest>> RequestQueue { get; private set; }
+    protected Simulation Environment { get; private set; }
+    protected SimplePriorityQueue<PreemptiveRequest> RequestQueue { get; private set; }
     protected Queue<Release> ReleaseQueue { get; private set; }
+    protected HashSet<Request> Users { get; private set; }
+    public PreemptiveResource(Environment environment, int capacity = 1) {
+    protected HashSet<PreemptiveRequest> Users { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
+    public PreemptiveResource(Simulation environment, int capacity = 1) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0.", "capacity");
       Environment = environment;
       Capacity = capacity;
       RequestQueue = new SortedList<int, LinkedList<PreemptiveRequest>>();
+      RequestQueue = new SimplePriorityQueue<PreemptiveRequest>();
       ReleaseQueue = new Queue<Release>();
+      Users = new HashSet<Request>();
+    }
+    public virtual PreemptiveRequest Request(int priority = 1, bool preempt = false) {
+      Users = new HashSet<PreemptiveRequest>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
+    public virtual PreemptiveRequest Request(double priority = 1, bool preempt = false) {
       var request = new PreemptiveRequest(Environment, TriggerRelease, DisposeCallback, priority, preempt);
+      if (!RequestQueue.ContainsKey(request.Priority))
+        RequestQueue.Add(request.Priority, new LinkedList<PreemptiveRequest>());
+      RequestQueue[request.Priority].AddLast(request);
+      RequestQueue.Enqueue(request);
       TriggerRequest();
       return request;
 …
+    }
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
     protected void DisposeCallback(Event @event) {
       var request = @event as PreemptiveRequest;
 …
       if (Users.Count >= Capacity && request.Preempt) {
         // Check if we can preempt another process
+        var oldest = Users.OfType<PreemptiveRequest>().Select((r, i) => new { Request = r, Index = i })
+          .OrderByDescending(x => x.Request.Priority)
+          .ThenByDescending(x => x.Request.Time)
+          .ThenByDescending(x => x.Request.Preempt)
+          .ThenByDescending(x => x.Index)
+          .First().Request;
+        if (oldest.Priority > request.Priority || (oldest.Priority == request.Priority
+            && (!oldest.Preempt && request.Preempt || (oldest.Preempt == request.Preempt
+              && oldest.Time > request.Time)))) {
+          Users.Remove(oldest);
+          oldest.Process.Interrupt(new Preempted(request.Process, oldest.Time));
+        // MaxItems are the least important according to priorty, time, and preemption flag
+        var preempt = Users.MaxItems(x => x).Last();
+        if (preempt.CompareTo(request) > 0) {
+          preempt.IsPreempted = true;
+          Users.Remove(preempt);
+          preempt.Owner?.Interrupt(new Preempted(request.Owner, preempt.Time));
+        }
+      }
 …
     protected virtual void DoRelease(Release release) {
+      if (!Users.Remove(release.Request)) {
+        var preemptRequest = release.Request as PreemptiveRequest;
+        if (preemptRequest != null) {
+          var current = RequestQueue[preemptRequest.Priority].First;
+          while (current != null && current.Value != release.Request)
+            current = current.Next;
+          if (current != null) RequestQueue[preemptRequest.Priority].Remove(current);
+        }
+      }
+      var req = (PreemptiveRequest)release.Request;
+      if (!Users.Remove(req) && !req.IsPreempted)
+        throw new InvalidOperationException("Released request does not have a user.");
       release.Succeed();
+    }
     protected virtual void TriggerRequest(Event @event = null) {
+      foreach (var entry in RequestQueue) {
+        var requests = entry.Value;
+        var current = requests.First;
+        while (current != null) {
+          var request = current.Value;
+          DoRequest(request);
+          if (request.IsTriggered) {
+            var next = current.Next;
+            requests.Remove(current);
+            current = next;
+          } else current = current.Next;
+        }
+      while (RequestQueue.Count > 0) {
+        var request = RequestQueue.First;
+        DoRequest(request);
+        if (request.IsTriggered) {
+          RequestQueue.Dequeue();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
+        } else break;
+      }
+    }
 …
       while (ReleaseQueue.Count > 0) {
         var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+        if (release.Request.IsAlive) {
+          if (!RequestQueue.TryRemove((PreemptiveRequest)release.Request))
+            throw new InvalidOperationException("Failed to cancel a request.");
+          release.Succeed();
           ReleaseQueue.Dequeue();
+        } else break;
+      }
+        } else {
+          DoRelease(release);
+          if (release.IsTriggered) {
+            ReleaseQueue.Dequeue();
+            TriggerWhenAny();
+            TriggerWhenFull();
+            TriggerWhenChange();
+          } else break;
+        }
+      }
+    }
+    protected virtual void TriggerWhenAny() {
+      if (Remaining > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenFull() {
+      if (InUse == 0) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenEmpty() {
+      if (Remaining == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PriorityResource.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
+  /// <summary>
+  /// A PriorityResource is similar to a <see cref="Resource"/>.
+  /// However, it enables prioritizing requests.
+  ///
+  /// PriorityResource holds a fixed number of anonymous entities.
+  /// Requests are processed in order priority first, FIFO second.
+  /// Releases are processed in FIFO order (usually no simulation time passes for a Release).
+  /// </summary>
   public class PriorityResource {
 …
     public int Remaining { get { return Capacity - InUse; } }
     protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
     protected SortedList<int, LinkedList<PriorityRequest>> RequestQueue { get; private set; }
+    protected SimplePriorityQueue<Request, double> RequestQueue { get; private set; }
     protected Queue<Release> ReleaseQueue { get; private set; }
     protected HashSet<Request> Users { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
     public PriorityResource(Environment environment, int capacity = 1) {
+    public PriorityResource(Simulation environment, int capacity = 1) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0.", "capacity");
       Environment = environment;
       Capacity = capacity;
       RequestQueue = new SortedList<int, LinkedList<PriorityRequest>>();
+      RequestQueue = new SimplePriorityQueue<Request, double>();
       ReleaseQueue = new Queue<Release>();
       Users = new HashSet<Request>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
+    public virtual PriorityRequest Request(int priority = 1) {
+      var request = new PriorityRequest(Environment, TriggerRelease, DisposeCallback, priority);
+      if (!RequestQueue.ContainsKey(priority))
+        RequestQueue.Add(priority, new LinkedList<PriorityRequest>());
+      RequestQueue[priority].AddLast(request);
+    public virtual Request Request(double priority = 1) {
+      var request = new Request(Environment, TriggerRelease, DisposeCallback);
+      RequestQueue.Enqueue(request, priority);
       TriggerRequest();
       return request;
+    }
     public virtual Release Release(PriorityRequest request) {
+    public virtual Release Release(Request request) {
       var release = new Release(Environment, request, TriggerRequest);
       ReleaseQueue.Enqueue(release);
 …
+    }
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
     protected void DisposeCallback(Event @event) {
       var request = @event as PriorityRequest;
+      var request = @event as Request;
       if (request != null) Release(request);
+    }
 …
     protected virtual void DoRelease(Release release) {
+      if (!Users.Remove(release.Request)) {
+        var prioRequest = release.Request as PriorityRequest;
+        if (prioRequest != null) {
+          var current = RequestQueue[prioRequest.Priority].First;
+          while (current != null && current.Value != release.Request)
+            current = current.Next;
+          if (current != null) RequestQueue[prioRequest.Priority].Remove(current);
+        }
+      }
+      if (!Users.Remove(release.Request))
+        throw new InvalidOperationException("Released request does not have a user.");
       release.Succeed();
+    }
     protected virtual void TriggerRequest(Event @event = null) {
+      foreach (var entry in RequestQueue) {
+        var cascade = false;
+        var requests = entry.Value;
+        while (requests.Count > 0) {
+          var req = requests.First.Value;
+          DoRequest(req);
+          if (req.IsTriggered) {
+            requests.RemoveFirst();
+          } else {
+            cascade = true;
+            break;
+          }
+        }
+        if (cascade) break;
+      while (RequestQueue.Count > 0) {
+        var request = RequestQueue.First;
+        DoRequest(request);
+        if (request.IsTriggered) {
+          RequestQueue.Dequeue();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
+        } else break;
+      }
+    }
 …
       while (ReleaseQueue.Count > 0) {
         var release = ReleaseQueue.Peek();
+        if (release.Request.IsAlive) {
+          if (!RequestQueue.TryRemove(release.Request))
+            throw new InvalidOperationException("Failed to cancel a request.");
+          release.Succeed();
+          ReleaseQueue.Dequeue();
+        }
         DoRelease(release);
         if (release.IsTriggered) {
           ReleaseQueue.Dequeue();
+          TriggerWhenAny();
+          TriggerWhenFull();
+          TriggerWhenChange();
         } else break;
+      }
+    }
+    protected virtual void TriggerWhenAny() {
+      if (Remaining > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenFull() {
+      if (InUse == 0) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenEmpty() {
+      if (Remaining == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }
+}

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Resource.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
+  /// <summary>
+  /// A resource holds a fixed number of anonymous entities.
+  ///
+  /// Requests are processed in FIFO order.
+  /// Releases are processed in FIFO order (usually no simulation time passes for a Release).
+  /// </summary>
   public class Resource {
 …
     public int Remaining { get { return Capacity - InUse; } }
     protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
     protected LinkedList<Request> RequestQueue { get; private set; }
     protected Queue<Release> ReleaseQueue { get; private set; }
     protected HashSet<Request> Users { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
     public Resource(Environment environment, int capacity = 1) {
+    public Resource(Simulation environment, int capacity = 1) {
       if (capacity <= 0) throw new ArgumentException("Capacity must > 0.", "capacity");
       Environment = environment;
 …
       ReleaseQueue = new Queue<Release>();
       Users = new HashSet<Request>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
 …
       TriggerRelease();
       return release;
+    }
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
 …
     protected virtual void DoRelease(Release release) {
+      if (!Users.Remove(release.Request)) {
+        var current = RequestQueue.First;
+        while (current != null && current.Value != release.Request)
+          current = current.Next;
+        if (current != null) RequestQueue.Remove(current);
+      }
+      if (!Users.Remove(release.Request))
+        throw new InvalidOperationException("Released request does not have a user.");
       release.Succeed();
+    }
 …
         if (request.IsTriggered) {
           RequestQueue.RemoveFirst();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
         } else break;
+      }
 …
       while (ReleaseQueue.Count > 0) {
         var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+        if (release.Request.IsAlive) {
+          if (!RequestQueue.Remove(release.Request))
+            throw new InvalidOperationException("Failed to cancel a request.");
+          release.Succeed();
           ReleaseQueue.Dequeue();
+        } else break;
+        } else {
+          DoRelease(release);
+          if (release.IsTriggered) {
+            ReleaseQueue.Dequeue();
+            TriggerWhenAny();
+            TriggerWhenFull();
+            TriggerWhenChange();
+          } else break;
+        }
+      }
+    }
+    protected virtual void TriggerWhenAny() {
+      if (Remaining > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenFull() {
+      if (InUse == 0) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenEmpty() {
+      if (Remaining == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/ResourcePool.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 namespace SimSharp {
+  /// <summary>
+  /// A ResourcePool is a crossover between a <see cref="Resource"/> and a <see cref="Store"/>.
+  /// There is a fixed number of non-anonymous resources.
+  ///
+  /// Requests are performed in FIFO order only when they match at least one resource in the pool.
+  /// Releases are processed in FIFO order (usually no simulation time passes for a Release).
+  /// </summary>
   public class ResourcePool {
     protected static readonly Func<object, bool> TrueFunc = _ => true;
 …
     public int Remaining { get { return Resources.Count; } }
     protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
     protected LinkedList<ResourcePoolRequest> RequestQueue { get; private set; }
     protected Queue<Release> ReleaseQueue { get; private set; }
     protected List<object> Resources { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
     public ResourcePool(Environment environment, IEnumerable<object> resources) {
+    public ResourcePool(Simulation environment, IEnumerable<object> resources) {
       Environment = environment;
       if (resources == null) throw new ArgumentNullException("resources");
 …
       RequestQueue = new LinkedList<ResourcePoolRequest>();
       ReleaseQueue = new Queue<Release>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
 …
       TriggerRelease();
       return release;
+    }
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
 …
           RequestQueue.Remove(current);
           current = next;
+          TriggerWhenEmpty();
+          TriggerWhenChange();
         } else current = current.Next;
         if (Resources.Count == 0) break;
 …
       while (ReleaseQueue.Count > 0) {
         var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+        if (release.Request.IsAlive) {
+          if (!RequestQueue.Remove((ResourcePoolRequest)release.Request))
+            throw new InvalidOperationException("Failed to cancel a request.");
+          release.Succeed();
           ReleaseQueue.Dequeue();
+        } else break;
+        } else {
+          DoRelease(release);
+          if (release.IsTriggered) {
+            ReleaseQueue.Dequeue();
+            TriggerWhenAny();
+            TriggerWhenFull();
+            TriggerWhenChange();
+          } else break;
+        }
+      }
+    }
+    protected virtual void TriggerWhenAny() {
+      if (Remaining > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenFull() {
+      if (InUse == 0) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenEmpty() {
+      if (Remaining == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Store.cs

-                      r15972
+                      r17053
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
 Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 This program is free software: you can redistribute it and/or modify
 …
 using System;
 using System.Collections.Generic;
-using System.Linq;
 namespace SimSharp {
+  /// <summary>
+  /// The store holds a variable number of individual items.
+  /// The items are removed from the store in FIFO order.
+  ///
+  /// Put are processed in FIFO order.
+  /// Get are processed in FIFO order.
+  /// </summary>
   public class Store {
+    public int Capacity { get; protected set; }
     public int Count { get { return Items.Count; } }
+    public int Capacity { get; protected set; }
     protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
     protected Queue<StorePut> PutQueue { get; private set; }
     protected Queue<StoreGet> GetQueue { get; private set; }
+    protected List<object> Items { get; private set; }
+    public Store(Environment environment, int capacity = int.MaxValue) {
+    protected Queue<object> Items { get; private set; }
+    protected List<Event> WhenNewQueue { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
+    public Store(Simulation environment, int capacity = int.MaxValue) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
       Environment = environment;
 …
       PutQueue = new Queue<StorePut>();
       GetQueue = new Queue<StoreGet>();
+      Items = new List<object>();
+      Items = new Queue<object>();
+      WhenNewQueue = new List<Event>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
+    public Store(Simulation environment, IEnumerable<object> items, int capacity = int.MaxValue) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      PutQueue = new Queue<StorePut>();
+      GetQueue = new Queue<StoreGet>();
+      Items = new Queue<object>(items);
+      WhenNewQueue = new List<Event>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+      if (capacity < Items.Count) throw new ArgumentException("There are more initial items than there is capacity.", "items");
+    }
 …
+    }
+    public virtual Event WhenNew() {
+      var whenNew = new Event(Environment);
+      WhenNewQueue.Add(whenNew);
+      return whenNew;
+    }
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
     protected virtual void DoPut(StorePut put) {
       if (Items.Count < Capacity) {
         Items.Add(put.Value);
+        Items.Enqueue(put.Value);
         put.Succeed();
+      }
 …
     protected virtual void DoGet(StoreGet get) {
       if (Items.Count > 0) {
+        var item = Items.First();
+        Items.RemoveAt(0);
+        var item = Items.Dequeue();
         get.Succeed(item);
+      }
 …
         if (put.IsTriggered) {
           PutQueue.Dequeue();
+          TriggerWhenNew();
+          TriggerWhenAny();
+          TriggerWhenFull();
+          TriggerWhenChange();
         } else break;
+      }
 …
         if (get.IsTriggered) {
           GetQueue.Dequeue();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
         } else break;
+      }
+    }
+    protected virtual void TriggerWhenNew() {
+      if (WhenNewQueue.Count == 0) return;
+      foreach (var evt in WhenNewQueue)
+        evt.Succeed();
+      WhenNewQueue.Clear();
+    }
+    protected virtual void TriggerWhenAny() {
+      if (Count > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenFull() {
+      if (Count == Capacity) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenEmpty() {
+      if (Count == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
+    }
+  }

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Properties/AssemblyInfo.cs

-                      r15972
+                      r17053
 [assembly: AssemblyCompany("HEAL")]
 [assembly: AssemblyProduct("SimSharp")]
 [assembly: AssemblyCopyright("(c) 2002-2018 HEAL")]
+[assembly: AssemblyCopyright("(c) 2002-2019 HEAL")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 …
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.0.11.0")]
 [assembly: AssemblyFileVersion("3.0.11.0")]
+[assembly: AssemblyVersion("3.1.1.0")]
+[assembly: AssemblyFileVersion("3.1.1.0")]

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Random/IRandom.cs

r15972	r17053
1	1	#region License Information
2	2	/* SimSharp - A .NET port of SimPy, discrete event simulation framework
3		Copyright (C) 2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
	3	Copyright (C) 2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4	4
5	5	This program is free software: you can redistribute it and/or modify

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Random/SystemRandom.cs

r15972	r17053
1	1	#region License Information
2	2	/* SimSharp - A .NET port of SimPy, discrete event simulation framework
3		Copyright (C) 2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
	3	Copyright (C) 2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4	4
5	5	This program is free software: you can redistribute it and/or modify

Context Navigation

Legend:

stable

stable/HeuristicLab.ExtLibs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Analysis/ContinuousStatistics.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Collections/EventQueue.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/ActiveObject.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Environment.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/AllOf.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/AnyOf.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Condition.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Event.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Process.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Events/Timeout.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Exceptions/EmptyScheduleException.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Preempted.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Container.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/ContainerGet.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/ContainerPut.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/FilterStoreGet.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/PreemptiveRequest.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/Release.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/Request.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/ResourcePoolRequest.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/StoreGet.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Events/StorePut.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/FilterStore.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PreemptiveResource.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PriorityResource.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Resource.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/ResourcePool.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Store.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Properties/AssemblyInfo.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Random/IRandom.cs

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Random/SystemRandom.cs

Download in other formats: