Пример #1
0
        /* dans cette fonction on initialise une liste de particule par rapport à un bloc donné
         * et on calcule le critere SAD entre ce bloc et le bloc généré aleatoirement*/
        private List <particule> initialiser(bloc BR)
        {
            Random           x     = new Random();
            List <particule> liste = new List <particule>();
            particule        tmp   = new particule();
            int cpt   = 0;
            int arret = 0;

            while (cpt < nbpar)
            {
                tmp.position.x = Math.Max(0, Math.Min(x.Next(BR.x - fenetre / 2, BR.x + fenetre / 2), w));
                tmp.position.y = Math.Max(0, Math.Min(x.Next(BR.y - fenetre / 2, BR.y + fenetre / 2), h));

                while (liste.Contains(tmp))
                {
                    tmp.position.x = Math.Max(0, Math.Min(x.Next(BR.x - fenetre / 2, BR.x + fenetre / 2), w));
                    tmp.position.y = Math.Max(0, Math.Min(x.Next(BR.y - fenetre / 2, BR.y + fenetre / 2), h));
                    arret++;
                    if (arret > 200)
                    {
                        break;
                    }
                }
                tmp.qualite = SAD(tmp.position, BR);
                // MessageBox.Show(tmp.position.x.ToString() + "," + tmp.position.y.ToString());

                liste.Add(tmp);
                cpt++;
            }
            //MessageBox.Show(cpt.ToString());
            return(liste);
        }
Пример #2
0
        private void initialiser_gbset_pbest(ref List <particule> pbest)
        {
            particule tmp = new particule();

            tmp.qualite = int.MaxValue;

            for (int i = 0; i < nbpar; i++)
            {
                pbest.Add(tmp);
            }
            gbest = tmp;
        }
Пример #3
0
        private void mise_a_jour_pbset_gbset(List <particule> liste, ref List <particule> pbest)
        {
            for (int i = 0; i < liste.Count; i++)
            {
                if (pbest[i].qualite > liste[i].qualite)
                {
                    pbest[i] = liste[i];
                }


                if (gbest.qualite > liste[i].qualite)
                {
                    gbest = liste[i];
                }
            }
        }
Пример #4
0
        /*cette fonction calcule les nouvelles positions a partir du gbest et le pbest
         * et mis à jour les SAD de ces nlles positions*/
        private void calcule_nouvelle_position(ref List <particule> l, bloc br, List <particule> pbest)
        {
            //Random x = new Random();
            particule tmp = new particule();
            bloc      bl = new bloc();
            int       deplacement, nouvelle_pos;
            double    s;

            for (int i = 0; i < l.Count; i++)
            //  AForge.Parallel.For(0, l.Count, delegate(int i)
            {
                bl = l[i].position;
                // deplacement =(int)(2 * x.NextDouble() * (pbest[i].position.x - l[i].position.x) + 2 * x.NextDouble() * (pbest[i].position.x * gbest.position.x - l[i].position.x));
                deplacement = (int)(c1 * bl.x + c_max * (pbest[i].position.x - bl.x - 1) + c_max * (gbest.position.x - bl.x - 1));

                //bl.x= bl.x + deplacement;
                nouvelle_pos = Math.Min(l[i].position.x + fenetre / 2, bl.x + deplacement);
                nouvelle_pos = Math.Max(nouvelle_pos, l[i].position.x - fenetre / 2);
                nouvelle_pos = Math.Max(0, Math.Min(nouvelle_pos, w));
                bl.x         = nouvelle_pos;
                //deplacement = (int)(2 * x.NextDouble() * (pbest[i].position.y - l[i].position.y) + 2 * x.NextDouble() * (pbest[i].position.y * gbest.position.y - l[i].position.y));

                deplacement = (int)(c1 * bl.y + c_max * (pbest[i].position.y - bl.y - 1) + c_max * (gbest.position.y - bl.y - 1));

                //bl.y = bl.y + deplacement;
                //bl.y=Math.Max(0, Math.Min(bl.y + deplacement, h));
                nouvelle_pos = Math.Min(l[i].position.y + fenetre / 2, bl.y + deplacement);
                nouvelle_pos = Math.Max(nouvelle_pos, l[i].position.y - fenetre / 2);
                nouvelle_pos = Math.Max(0, Math.Min(nouvelle_pos, h));
                bl.y         = nouvelle_pos;
                //   MessageBox.Show(bl.x.ToString()+","+bl.y.ToString());
                s            = SAD(bl, br);
                tmp.position = bl;
                tmp.qualite  = s;
                l[i]         = tmp;
                //  MessageBox.Show(bl.x.ToString()+","+bl.y.ToString());
            }
            //);
        }
Пример #5
0
        private void mise_a_jour_pbset_gbset(List<particule> liste,ref List<particule> pbest)
        {
            for (int i = 0; i <liste.Count; i++)
            {

                if (pbest[i].qualite > liste[i].qualite)
                    pbest[i] = liste[i];

                if (gbest.qualite > liste[i].qualite)
                        gbest = liste[i];

            }
        }
Пример #6
0
        private void initialiser_gbset_pbest(ref List<particule> pbest)
        {
            particule tmp = new particule();
            tmp.qualite = int.MaxValue;

            for (int i = 0; i < nbpar; i++)
            {
                pbest.Add(tmp);
            }
               gbest = tmp;
        }
Пример #7
0
        /* dans cette fonction on initialise une liste de particule par rapport à un bloc donné
         * et on calcule le critere SAD entre ce bloc et le bloc généré aleatoirement*/
        private List<particule> initialiser(bloc BR)
        {
            Random x = new Random();
            List<particule> liste = new List<particule>();
            particule tmp = new particule();
            int cpt =0;
            int arret = 0;
            while(cpt<nbpar)
            {
                tmp.position.x = Math.Max(0, Math.Min(x.Next(BR.x - fenetre / 2, BR.x + fenetre / 2), w));
                tmp.position.y = Math.Max(0, Math.Min(x.Next(BR.y - fenetre / 2, BR.y + fenetre / 2), h));

                while (liste.Contains(tmp))
                {
                    tmp.position.x = Math.Max(0, Math.Min(x.Next(BR.x - fenetre / 2, BR.x + fenetre / 2), w));
                    tmp.position.y = Math.Max(0, Math.Min(x.Next(BR.y - fenetre / 2, BR.y + fenetre / 2), h));
                    arret++;
                    if (arret > 200) break;
                }
                tmp.qualite = SAD(tmp.position, BR);
               // MessageBox.Show(tmp.position.x.ToString() + "," + tmp.position.y.ToString());

                liste.Add(tmp);
                cpt++;
            }
            //MessageBox.Show(cpt.ToString());
            return liste;
        }
Пример #8
0
        /*cette fonction calcule les nouvelles positions a partir du gbest et le pbest
         * et mis à jour les SAD de ces nlles positions*/
        private void calcule_nouvelle_position(ref List<particule> l, bloc br, List<particule> pbest)
        {
            //Random x = new Random();
            particule tmp = new particule();
            bloc bl = new bloc();
            int deplacement,nouvelle_pos;
            double s;
            for (int i = 0; i < l.Count; i++)
              //  AForge.Parallel.For(0, l.Count, delegate(int i)
            {
                 bl = l[i].position;
                // deplacement =(int)(2 * x.NextDouble() * (pbest[i].position.x - l[i].position.x) + 2 * x.NextDouble() * (pbest[i].position.x * gbest.position.x - l[i].position.x));
                     deplacement = (int)(c1 * bl.x + c_max * (pbest[i].position.x - bl.x - 1) + c_max * (gbest.position.x - bl.x - 1));

                //bl.x= bl.x + deplacement;
                nouvelle_pos = Math.Min(l[i].position.x + fenetre / 2, bl.x + deplacement);
                nouvelle_pos = Math.Max(nouvelle_pos, l[i].position.x - fenetre / 2);
                nouvelle_pos = Math.Max(0, Math.Min(nouvelle_pos, w));
                bl.x = nouvelle_pos;
                //deplacement = (int)(2 * x.NextDouble() * (pbest[i].position.y - l[i].position.y) + 2 * x.NextDouble() * (pbest[i].position.y * gbest.position.y - l[i].position.y));

                        deplacement = (int)(c1 * bl.y + c_max * (pbest[i].position.y - bl.y - 1) + c_max * (gbest.position.y - bl.y - 1));

                //bl.y = bl.y + deplacement;
                //bl.y=Math.Max(0, Math.Min(bl.y + deplacement, h));
                nouvelle_pos = Math.Min(l[i].position.y + fenetre / 2, bl.y + deplacement);
                nouvelle_pos = Math.Max(nouvelle_pos, l[i].position.y - fenetre / 2);
                nouvelle_pos = Math.Max(0, Math.Min(nouvelle_pos, h));
                bl.y = nouvelle_pos;
                //   MessageBox.Show(bl.x.ToString()+","+bl.y.ToString());
                s = SAD(bl, br);
                tmp.position = bl;
                tmp.qualite = s;
                l[i] = tmp;
                //  MessageBox.Show(bl.x.ToString()+","+bl.y.ToString());
            }
            //);
        }