public string printPreparedTranzitions()
        {
            string result = string.Empty;

            result = string.Join(", ", PreparedTransitions.Select(i => i.Number));
            return(result);
        }
        private void SortTransitions()
        {
            if (sortList.Count == 3)
            {
                PreparedTransitions = PreparedTransitions
                                      .OrderBy(i => i.ProcessTime)
                                      .ThenBy(i => i.arrivalTime)
                                      .ThenBy(i => i.MachineConnected)
                                      .ToList();
            }

            else if (sortList.Any(i => i == sortAlgorithm.MCF))
            {
                PreparedTransitions = PreparedTransitions.OrderByDescending(i => i.MachineConnected == true).ToList();
            }

            else if (sortList.Any(i => i == sortAlgorithm.STF))
            {
                PreparedTransitions = PreparedTransitions
                                      .OrderBy(i => i.ProcessTime).ToList();
            }
            else if (sortList.Any(i => i == sortAlgorithm.FIFO))
            {
                PreparedTransitions = PreparedTransitions.
                                      OrderBy(i => i.arrivalTime).ToList();
            }
        }
 private void clearData()
 {
     Machines        = 0;
     ProcessesAmount = 0;
     Processes.Clear();
     Buffers.Clear();
     Inputs.Clear();
     PreparedTransitions.Clear();
 }
        public Vector <double> chooseTransiztion(TimerController timer, Matrix <double> M)
        {
            var T = Vector <double> .Build.Dense(petriNet.Tranzitions, 0);

            if (PreparedTransitions.Count > 0)
            {
                for (int i = 0; i < PreparedTransitions.Count; i++)
                {
                    T = Vector <double> .Build.Dense(petriNet.Tranzitions, 0);

                    var Tr = PreparedTransitions.ElementAt(i);
                    T[Tr.Number - 1] = 1;
                    var MM = M + petriNet.I * T.ToColumnMatrix();
                    if (transitionIsSafe(Tr.IO, Tr.Number, M, MM, Tr))
                    {
                        PreparedTransitions.RemoveAt(i);
                        //Console.Out.WriteLine("Transition: " + Tr.Number);
                        var machine = transitionFromMachine(Tr.IO);

                        if (machine > 0)
                        {
                            int processNumber = getProcessNumber(Tr.Number - 1);
                            var operation     = Processes.First(p => p.Number == processNumber)
                                                .Operations.First(o => o.MachineNumber == machine);
                            if (processNumber > 0)
                            {
                                timer.StartOperation(operation, processNumber);
                            }
                        }
                        var tmpBuffers = Buffers;
                        updateBuffers(Tr);
                        return(T);
                    }
                }
            }
            T = Vector <double> .Build.Dense(petriNet.Tranzitions, 0);

            return(T);
        }
        public List <Transition> getPreparedTransitions(int time,
                                                        TimerController timer, Matrix <double> M)
        {
            List <Transition> CurrentTransitions = new List <Transition>();
            List <Transition> tmpPrepared        = new List <Transition>();

            PreparedTransitions.ForEach(i => tmpPrepared.Add(i));
            for (int t = 0; t < petriNet.Tranzitions; t++)
            {
                if (transitionPrepared(petriNet.I.Column(t), timer, M))
                {
                    var newTransition = generateTransitionInfo(t, time);

                    CurrentTransitions.Add(newTransition);
                }
            }
            foreach (var transition in PreparedTransitions)
            {
                if (CurrentTransitions.All(i => i.Number != transition.Number))
                {
                    tmpPrepared.Remove(transition);
                }
            }
            foreach (var transition in CurrentTransitions)
            {
                if (PreparedTransitions.All(i => i.Number != transition.Number) ||
                    PreparedTransitions.Count == 0)
                {
                    tmpPrepared.Add(transition);
                }
            }
            PreparedTransitions = tmpPrepared;

            SortTransitions();

            return(PreparedTransitions);
        }