Построение и реализация моделирующих алгоритмов q-схем. Метод “ΔT”

    /// <summary>
    /// Генерирует  сигналы через случайные промежутки вермени
    /// </summary>
    public abstract class Generator
    {
        protected static Random rnd = new Random(1);
 
        //время следующего сигнала
        protected double nextSignalTime;
 
        /// <summary>
        /// Проверить, наступило ли время сигнала, и если да, то сгенерировать следующий сигнал
        /// </summary>
        public virtual bool CheckAndGenerate(double currentTime)
        {
            if (nextSignalTime <= currentTime)
            {
                GenerateNextSignalTime(currentTime);
                return true;
            }
 
            return false;
        }
 
        /// <summary>
        /// Генерация след сигнала
        /// </summary>
        protected abstract void GenerateNextSignalTime(double currentTime);
    }
 
    /// <summary>
    /// Генератор сигнала с равномерным распределением
    /// </summary>
    public class LinearGenerator : Generator
    {
        double min;
        double max;
 
        public LinearGenerator( double min, double max)
        {
            this.min = min;
            this.max = max;
        }
 
        protected override void GenerateNextSignalTime(double currentTime)
        {
            var t = min + rnd.NextDouble() * (max - min);
            nextSignalTime = currentTime + t;
        }
    }
 
    /// <summary>
    /// Генератор сигнала с экспоненциальным распределением
    /// </summary>
    public class ExponentialGenerator : Generator
    {
        double mean;
 
        public ExponentialGenerator(double mean)
        {
            this.mean = mean;
        }
 
        protected override void GenerateNextSignalTime(double currentTime)
        {
            var t = -mean * Math.Log(rnd.NextDouble());
            nextSignalTime = currentTime + t;
        }
    }
 
 
    /// <summary>
    /// Канал обслуживания с накопителем
    /// (равномерное распределение времени обслуживания)
    /// </summary>
    class ServiceChannel : LinearGenerator
    {
        /// <summary>
        /// Текущая длина очереди
        /// </summary>
        public int QueueLength { get; private set;}
 
        public ServiceChannel(double min, double max) : base(min, max)
        {
        }
 
        /// <summary>
        /// Добавление заявки в очередь
        /// </summary>
        public void AddRequest(double currentTime)
        {
            if(QueueLength == 0)
                GenerateNextSignalTime(currentTime);
 
            QueueLength++;
        }
 
        /// <summary>
        /// Обрабатываем заявки
        /// </summary>
        public override bool CheckAndGenerate(double currentTime)
        {
            if (QueueLength <= 0)
                return false;//нет заявок в очереди
 
            if (nextSignalTime <= currentTime)
            {
                GenerateNextSignalTime(currentTime);
                QueueLength--;//обрабатываем заявку
                return true;
            }
 
            return false;
        }
    }
 
    /// <summary>
    /// Решатель
    /// </summary>
    class Solver
    {
        public Generator G1;
        public Generator G2;
        public ServiceChannel U1;
        public ServiceChannel U2;
 
        private double time = 0;
 
        public Solver(Generator G1, Generator G2, ServiceChannel U1, ServiceChannel U2)
        {
            this.G1 = G1;
            this.G2 = G2;
            this.U1 = U1;
            this.U2 = U2;
        }
 
        public void Run(double dt)
        {
            if (G1.CheckAndGenerate(time))
                U1.AddRequest(time);
 
            if (U1.CheckAndGenerate(time))
                U2.AddRequest(time);
 
            if (G2.CheckAndGenerate(time))
                U2.AddRequest(time);
 
            U2.CheckAndGenerate(time);
 
            time += dt;
        }
    }