Exemple #1
0
        //изменение кол-ва ферромона после прохождения муравья
        public static void updateFerromon(List <Vertex> list, Muravey muravey, Duga[,] curves)
        {
            double delta = deltaTau(muravey, curves);
            int    count = 0;

            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list.Count; j++)
                {
                    if (curves[i, j] != null)
                    {
                        curves[i, j].T = (1 - EVAPORATION_COEF) * curves[i, j].T;
                        //если по дуге прошел муравей
                        if (vertexContains(muravey.Way, i, j))
                        {
                            curves[i, j].T += delta;
                            if (i == 0)
                            {
                                count++;
                            }
                        }
                    }
                }
            }
        }
Exemple #2
0
        public static void antAlhoritm(List <Vertex> list, Muravey muravey, List <int> ListVirtual, Duga[,] curves, BRANCH branch)
        {
            int CurrentMashine = startNode(list, curves, branch);

            //перезапись в первоначальные значения эвристической ф-ии
            restartEvristic(list, curves);

            while (!muravey.Tabu.SequenceEqual(ListVirtual))
            {
                //добавление текущей вершины к пути муравья
                muravey.Way.Add(CurrentMashine);
                //добавление текущей вершины в список табу для муравья
                muravey.Tabu.Add(CurrentMashine);

                //получение следующей физической вершины (вирт ->физ)
                int indVertex = roulettePath(list, CurrentMashine, branch, MACHINE.REAL, muravey, curves);
                if (indVertex != 0)
                {
                    //добавление вершины к пути муравья
                    muravey.Way.Add(indVertex);
                    //присвоение вирт машины физической
                    addTarget(list, CurrentMashine, indVertex, muravey, curves);
                    //добавление вершины к пути муравья(возврат к вирт. машине)
                    muravey.Way.Add(CurrentMashine);
                }

                //получение индекса вирт.машины, к которой переходит муравей (вирт ->вирт)
                CurrentMashine = roulettePath(list, CurrentMashine, branch, MACHINE.VIRTUAL, muravey, curves);
                //если все вирт.машины посещены,то возврат к исходному
                if (CurrentMashine == 0)
                {
                    muravey.Way.Add(CurrentMashine); break;
                }
            }
        }
Exemple #3
0
        //добавление дуг в графе
        static void addCurves(List <Vertex> list, Duga[,]  curves)
        {
            Muravey muravey = new Muravey(0);

            for (int i = 0; i < list.Count - 1; i++)
            {
                for (int j = i + 1; j < list.Count; j++)
                {
                    if (
                        (list[i].Type == MACHINE.VIRTUAL && list[j].Type == MACHINE.VIRTUAL && list[i].Branch == BRANCH.CALCULATIVE && list[j].Branch == BRANCH.CALCULATIVE) ||
                        (list[i].Type == MACHINE.VIRTUAL && list[j].Type == MACHINE.REAL && list[i].Branch == BRANCH.CALCULATIVE && list[j].Branch == BRANCH.CALCULATIVE) ||
                        (list[i].Type == MACHINE.VIRTUAL && list[j].Type == MACHINE.VIRTUAL && list[i].Branch == BRANCH.STORAGE && list[j].Branch == BRANCH.STORAGE) ||
                        (list[i].Type == MACHINE.VIRTUAL && list[j].Type == MACHINE.REAL && list[i].Branch == BRANCH.STORAGE && list[j].Branch == BRANCH.STORAGE))
                    {
                        curves[i, j] = new Duga(1, Evristic(i, j, muravey, list));
                        curves[j, i] = new Duga(1, Evristic(j, i, muravey, list));
                    }
                    if
                    (list[i].Type == MACHINE.ROOT && list[j].Type == MACHINE.VIRTUAL)
                    {
                        curves[i, j] = new Duga(1, 1);
                        curves[j, i] = new Duga(1, 1);
                    }
                }
            }
        }
Exemple #4
0
 public void setTheBestWay(Muravey muravey)
 {
     if (muravey.target.Count >= Target.Count)
     {
         Way    = muravey.Way;
         Target = muravey.target;
     }
 }
Exemple #5
0
        //вычисление дельта-тау для муравья
        public static double deltaTau(Muravey muravey, Duga[,] curves)
        {
            double sum = 0;

            for (int k = 0; k < (muravey.Way.Count - 1); k++)
            {
                int i = muravey.Way[k];
                int j = muravey.Way[k + 1];
                if (vertexContains(muravey.Way, i, j) && curves[i, j] != null)
                {
                    sum += curves[i, j].N * Q;
                }
            }
            return(sum);
        }
Exemple #6
0
        //назначение дугам первоначальных значений эвристической ф-ии после прохода каждого муравья
        private static void restartEvristic(List <Vertex> list, Duga[,] curves)
        {
            Muravey muravey = new Muravey(0);

            for (int i = 1; i < list.Count; i++)
            {
                for (int j = 1; j < list.Count; j++)
                {
                    if (curves[i, j] != null)
                    {
                        curves[i, j].N = Evristic(i, j, muravey, list);
                    }
                }
            }
        }
Exemple #7
0
        private static double Evristic(int i, int j, Muravey muravey, List <Vertex> list)
        {
            if (list[i].Type == MACHINE.VIRTUAL && list[j].Type == MACHINE.VIRTUAL)
            {
                int max = 0;
                for (int k = 0; k < list.Count; k++)
                {
                    if (list[k].Core > max)
                    {
                        max = list[k].Core;
                    }
                }
                double result = (double)list[j].Core / max;
                if (result > 1)
                {
                    return(0);
                }
                else
                {
                    return(result);
                }
            }
            if ((list[i].Type == MACHINE.VIRTUAL && list[j].Type == MACHINE.REAL) ||
                (list[j].Type == MACHINE.VIRTUAL && list[i].Type == MACHINE.REAL))
            {
                int sum = 0;
                if (muravey.target.ContainsValue(list[j].Num))
                {
                    var keys = muravey.target.Where(x => x.Value == list[j].Num).ToList();

                    foreach (var k in keys)
                    {
                        sum += list[(int)k.Key].Core;
                    }
                }
                double result = (double)(sum + list[i].Core) / (double)list[j].Core;
                if (result > 1)
                {
                    return(0);
                }
                else
                {
                    return(result);
                }
            }
            throw new Exception("Машины имеют не допустимый тип: " + i.ToString() + ", " + j.ToString());
        }
Exemple #8
0
 //назначение вирт.машины физической для муравья и пересчет эвристической ф-ии
 public static void addTarget(List <Vertex> list, int CurrentMashine, int RealMachine, Muravey muravey, Duga[,] curves)
 {
     muravey.target.Add(CurrentMashine, RealMachine);
     for (int i = 0; i < list.Count; i++)
     {
         if (list[i].Type == MACHINE.VIRTUAL && curves[i, RealMachine] != null)
         {
             curves[i, RealMachine].N = Evristic(i, RealMachine, muravey, list);
         }
     }
 }
Exemple #9
0
        public static int roulettePath(List <Vertex> list, int CurrentMashine, BRANCH branch, MACHINE machine, Muravey muravey, Duga[,] curves)
        {
            //Dictionary для хранения вероятностей перехода  вирт--->физ
            Dictionary <int, double> P = new Dictionary <int, double>();
            int    indVertex           = 0;
            double p;

            //находнеие вероятностей перехода
            for (int j = 0; j < list.Count; j++)
            {
                //существут дуга && соотв. тип (вирт./физ.) && соответствут ветка (вычислит./storage)
                if (curves[CurrentMashine, j] != null && (list[j].Type == machine && list[j].Branch == branch))
                {
                    if ((machine == MACHINE.VIRTUAL && !muravey.Tabu.Contains(j)) || machine == MACHINE.REAL)
                    {
                        //верроятность перехода
                        p = Math.Pow(curves[CurrentMashine, j].T, ALPHA) * Math.Pow(curves[CurrentMashine, j].N, BETA) / ZnamenatelP(list, CurrentMashine, branch, machine, curves, muravey);
                    }
                    else
                    {
                        p = 0;
                    }
                    P.Add(j, p);
                }
            }

            return(indVertex = rouletteChouse(P));
        }
Exemple #10
0
        //муравьиный алгорит
        public static void Algoritm(string file)
        {
            //список вершин (вирт. машин +физ. вычислительных узлов)
            List <Vertex> vertex = new List <Vertex>();

            vertex.Add(new Vertex(0, BRANCH.ROOT, MACHINE.ROOT, 0));
            //массив дуг
            Duga[,] dugi;
            theBestSolution solution;

            Muravey[] muravey = new Muravey[COUNT_MURAVEY];

            //заполнение списков vertex и  storage
            readInputfromFile(file, vertex);

            dugi     = new Duga[vertex.Count, vertex.Count];
            solution = new theBestSolution(vertex.Count);
            //добавление дуг в графе
            addCurves(vertex, dugi);

            int[] count = new int[4];
            //список вирт машин
            List <int> ListVirtual_vertex = new List <int>();

            for (int i = 0; i < vertex.Count; i++)
            {
                if (vertex[i].Type == MACHINE.VIRTUAL && vertex[i].Branch == BRANCH.CALCULATIVE)
                {
                    ListVirtual_vertex.Add(vertex[i].Num);
                    count[0]++;
                }
                if (vertex[i].Type == MACHINE.REAL && vertex[i].Branch == BRANCH.CALCULATIVE)
                {
                    count[1]++;
                }
                if (vertex[i].Type == MACHINE.VIRTUAL && vertex[i].Branch == BRANCH.STORAGE)
                {
                    count[2]++;
                }
                if (vertex[i].Type == MACHINE.REAL && vertex[i].Branch == BRANCH.STORAGE)
                {
                    count[3]++;
                }
            }
            //список вирт.элементов во всем графе
            List <int> ListVirtual_storage = new List <int>();

            for (int i = 0; i < vertex.Count; i++)
            {
                if (vertex[i].Type == MACHINE.VIRTUAL)
                {
                    ListVirtual_storage.Add(vertex[i].Num);
                }
            }

            //проход муравьями графа
            for (int m = 0; m < COUNT_MURAVEY; m++)
            {
                muravey[m] = new Muravey(0);
                //обход левой части графа(вирт.машины+физич.узлы)
                antAlhoritm(vertex, muravey[m], ListVirtual_vertex, dugi, BRANCH.CALCULATIVE);

                //Console.WriteLine();
                //обход правой части графа(storage-элементы +хранилища данных)
                antAlhoritm(vertex, muravey[m], ListVirtual_storage, dugi, BRANCH.STORAGE);

                //изменение кол-ва ферромона на дугах
                updateFerromon(vertex, muravey[m], dugi);



                // Console.WriteLine();

                //сортировка списка соответствий по ключу
                muravey[m].target = muravey[m].target.OrderBy(pair => pair.Key).ToDictionary(pair => pair.Key, pair => pair.Value);
                solution.setTheBestWay(muravey[m]);
            }
            //оценка сходимости алгоритма
            solution.estimateWay(muravey);
            solution.theAdjacencyMatrixOfAGraph(vertex, dugi);
            //Deigstra(vertex, solution.AdjacencyMatrix);

            int[] rezult = new int[2];
            foreach (int i in solution.Target.Keys)
            {
                for (int k = 0; k < vertex.Count; k++)
                {
                    if (i == k)
                    {
                        if (vertex[i].Type == MACHINE.VIRTUAL && vertex[i].Branch == BRANCH.CALCULATIVE)
                        {
                            rezult[0]++;
                        }
                        if (vertex[i].Type == MACHINE.VIRTUAL && vertex[i].Branch == BRANCH.STORAGE)
                        {
                            rezult[1]++;
                        }
                    }
                }
            }

            Console.WriteLine(String.Format("|{0,15}|{1,7}|{2,7}|{3,11}|{4,10}|{5,8}|{6,14}|", file, count[0], count[1], rezult[0], count[2], count[3], rezult[1]));
            Console.WriteLine(String.Format("+---------------+-------+-------+-----------+----------+--------+--------------+"));
            Console.ReadKey();
        }
Exemple #11
0
        //вычисление знаменателя в формуле вероятности (для выбора пути муравьем)
        public static double ZnamenatelP(List <Vertex> list, int i, BRANCH branch, MACHINE type, Duga[,] curves, Muravey muravey)
        {
            double sum = 0;

            for (int j = 0; j < list.Count; j++)
            {
                if (curves[i, j] != null && list[j].Type == type && list[j].Branch == branch && !muravey.Tabu.Contains(j))
                {
                    sum += Math.Pow(curves[i, j].T, ALPHA) * Math.Pow(curves[i, j].N, BETA);
                }
            }
            return(sum);
        }