Exemple #1
0
        private IList <TaskPair> FindParents()
        {
            ICollection <TaskPair> parentSet = new SortedSet <TaskPair>
            {
                new TaskPair(IndividualTask.X_start, IndividualTask.count_fx(IndividualTask.X_start))
            };

            for (int i = 0; i < parentsQuantity - 1; i++)
            {
                TaskPair newTaskPair = new TaskPair();
                int[]    x_new       = new int[n];
                Array.Copy(IndividualTask.X_start, x_new, n);
                for (int j = 0; j < n; j++)
                {
                    int boolval = rand.Next(2);
                    if (boolval == 1)
                    {
                        x_new[j] += rand.Next(
                            Math.Max(-5, (IndividualTask.Constraints[j][0] - IndividualTask.X_start[j])),
                            Math.Min(6, (IndividualTask.Constraints[j][1] - IndividualTask.X_start[j])));
                    }
                }
                newTaskPair.X  = x_new;
                newTaskPair.Fx = IndividualTask.count_fx(x_new);
                parentSet.Add(newTaskPair);
            }
            parentsQuantity = parentsQuantity / 3;
            if (parentsQuantity % 2 != 0)
            {
                parentsQuantity++;
            }
            return(parentSet.Take(parentsQuantity).ToList());
        }
Exemple #2
0
        public TaskPair ExecuteAlgorithm()
        {
            IList <TaskPair> parents = FindParents();
            long             record  = parents.First().Fx;
            int      lasting         = 0;
            TaskPair taskPair        = get_children(parents, record, lasting);

            return(taskPair);
        }
Exemple #3
0
        private TaskPair ExecuteGeneticAndSaveResults(Task task)
        {
            Genetic genetic = new Genetic(task, 100);

            timeCounter = Stopwatch.StartNew();
            TaskPair pair1 = genetic.ExecuteAlgorithm();

            timeCounter.Stop();
            geneticTime.Add(timeCounter.ElapsedTicks);
            return(pair1);
        }
Exemple #4
0
        private TaskPair ExecuteAnnealingAndSaveResults(Task task)
        {
            SimulatedAnnealing simulatedAnnealing = new SimulatedAnnealing(task, 200, 10);

            timeCounter = Stopwatch.StartNew();
            TaskPair pair2 = simulatedAnnealing.executeAlgorithm();

            timeCounter.Stop();
            annealingTime.Add(timeCounter.ElapsedTicks);
            return(pair2);
        }
Exemple #5
0
        private TaskPair generateChild(TaskPair parent1, TaskPair parent2) //генеруємо нащадка
        {
            TaskPair child = new TaskPair();

            child.X = new int[this.n];
            for (int i = 0; i < n; i++)
            {
                double alpha = Convert.ToDouble(rand.Next(-25, 125)) / 100;
                child.X[i] = Convert.ToInt32(parent1.X[i] + alpha * (parent2.X[i] - parent1.X[i]));
            }
            child.Fx = IndividualTask.count_fx(child.X);
            return(child);
        }
Exemple #6
0
        private bool balanceIsReached(IList <TaskPair> points, TaskPair currentPoint, float epsilon)
        {
            IList <double> Ratio = new List <double>();

            foreach (TaskPair point in points)
            {
                if (point != currentPoint)
                {
                    Ratio.Add(Convert.ToDouble(Math.Abs(point.Fx - currentPoint.Fx)) / point.Fx);
                }
            }
            return((Ratio.Count != 0)?(Ratio.Min() <= epsilon):false);
        }
Exemple #7
0
        private bool childIsAdmissible(TaskPair child)
        {
            bool admissible = true;

            for (int i = 0; i < n; i++)
            {
                if (child.X[i] < IndividualTask.Constraints[i][0] ||
                    child.X[i] > IndividualTask.Constraints[i][1])
                {
                    admissible = false;
                    break;
                }
            }
            return(admissible);
        }
Exemple #8
0
        public CounterResult CountTime(int i, int productsQuantity, int leftSum, int rightSum, int leftAmount, int rightAmount)
        {
            List <TaskPair[]> Fxs    = new List <TaskPair[]>();
            CounterResult     result = new CounterResult();
            //int i = 1000;               //user-defined number of Individual Tasks to generate
            int geneticBetter = 0;
            int annealBetter  = 0;
            int wolfBetter    = 0;

            //int productsQuantity = 3; //may be randomized or user-defined
            while (i != 0)
            {
                Order      generatedOrder = RandomHandler.GetRandomizedOrder(productsQuantity, leftSum, rightSum, leftAmount, rightAmount);
                Task       task           = ConvertOrderToTask(generatedOrder);
                TaskPair   pair1          = ExecuteGeneticAndSaveResults(task);
                TaskPair   pair2          = ExecuteAnnealingAndSaveResults(task);
                TaskPair   pair3          = ExecuteFrankWolfAndSaveResults(generatedOrder, task);
                TaskPair[] pairs          = new TaskPair[3] {
                    pair1, pair2, pair3
                };
                //counting situations when one algorithm gives results better than other
                //(you can remove it or use to compare results)
                if (pair1.Fx != 0 || pair2.Fx != 0 || pair3.Fx != 0)
                {
                    if (pair1.Fx <= pair2.Fx && pair1.Fx <= pair3.Fx)
                    {
                        geneticBetter++;
                    }
                    if (pair2.Fx <= pair1.Fx && pair2.Fx <= pair3.Fx)
                    {
                        annealBetter++;
                    }
                    if (pair3.Fx <= pair1.Fx && pair3.Fx <= pair2.Fx)
                    {
                        wolfBetter++;
                    }
                }
                Fxs.Add(pairs);
                i--;
            }
            result.AnnealAvg     = annealingTime.Average();
            result.GeneticAvg    = geneticTime.Average();
            result.WolfAvg       = wolfTime.Average();
            result.GeneticBetter = geneticBetter;
            result.AnnealBetter  = annealBetter;
            result.FrankBetter   = wolfBetter;
            return(result);
        }
Exemple #9
0
        public TaskPair executeAlgorithm()
        {
            int   temperature = startTemperature;
            int   h           = 0;
            float epsilon     = 0.01F;

            int[] x_current = new int[n];
            Array.Copy(IndividualTask.X_start, x_current, n);
            TaskPair bestSolution    = new TaskPair(x_current, IndividualTask.count_fx(x_current));
            TaskPair currentSolution = bestSolution;

            while (h <= H && bestSolution.Fx != 0 && temperature != 0)
            {
                IList <TaskPair> z = new List <TaskPair>();
                while (bestSolution.Fx != 0 && !balanceIsReached(z, currentSolution, epsilon))
                {
                    z.Add(currentSolution);
                    TaskPair Y = generateNewPoint(x_current);
                    if (Y.Fx == 0)
                    {
                        bestSolution = Y;
                        break;
                    }
                    long   delta  = Y.Fx - currentSolution.Fx;
                    double p      = Math.Min(1, Math.Pow(Math.E, (-delta / temperature)));
                    int    minKsi = 75 + (75 * (temperature - startTemperature) / startTemperature);
                    int    maxKsi = 100 * temperature / startTemperature;
                    double ksi    = Convert.ToDouble(rand.Next(minKsi, maxKsi + 1)) / 100;
                    if (p > ksi || delta < 0)
                    {
                        currentSolution = Y;
                        if (Y.Fx < bestSolution.Fx)
                        {
                            bestSolution = Y;
                        }
                    }
                }
                h++;
                double alpha = Convert.ToDouble(rand.Next(50, 100)) / 100;
                temperature = Convert.ToInt32(temperature * alpha);
            }
            return(bestSolution);
        }
Exemple #10
0
        private TaskPair get_children(IList <TaskPair> parents, long record, int lasting)
        {
            if (parents.Count == 1)
            {
                return(parents.ElementAt(0));
            }
            if (parents.Count % 2 != 0)
            {
                parents.RemoveAt(parents.Count - 1);
            }
            ICollection <TaskPair> iterationNodes = new SortedSet <TaskPair>();

            foreach (TaskPair parent in parents)
            {
                iterationNodes.Add(parent);
            }
            TaskPair.Shuffle(parents);
            for (int k = 0; k < parents.Count; k += 2)
            {
                int quantity = rand.Next(1, 5);
                while (quantity != 0)
                {
                    TaskPair child = generateChild(parents[k], parents[k + 1]);
                    ChildMutation(child);
                    if (childIsAdmissible(child))
                    {
                        child.Fx = IndividualTask.count_fx(child.X);
                        iterationNodes.Add(child);
                        quantity--;
                    }
                }
            }
            long newRecord = iterationNodes.First().Fx;

            if ((newRecord == record && lasting == 99) || newRecord == 0)
            {
                return(iterationNodes.First());
            }
            else
            {
                IList <TaskPair> iterationNodesList = iterationNodes
                                                      .Take(3 * iterationNodes.Count / 4)
                                                      .ToList();
                IList <TaskPair> new_nodes = iterationNodes
                                             .Take(parentsQuantity / 2)
                                             .ToList();
                foreach (TaskPair addedNode in new_nodes)
                {
                    iterationNodesList.Remove(addedNode);
                }
                TaskPair.Shuffle(iterationNodesList);
                for (int i = 0; i < Math.Min(parentsQuantity / 2, iterationNodesList.Count); i++)
                {
                    new_nodes.Add(iterationNodesList.ElementAt(i));
                }
                if (new_nodes.Count % 2 != 0)
                {
                    new_nodes.RemoveAt(new_nodes.Count - 1);
                }
                if (newRecord == record)
                {
                    return(get_children(new_nodes, newRecord, lasting + 1));
                }
                else
                {
                    return(get_children(new_nodes, newRecord, 0));
                }
            }
        }
Exemple #11
0
        private void ChildMutation(TaskPair child)
        {
            int IdxToMutate = rand.Next(n);

            child.X[IdxToMutate]--;
        }