pso.h

Go to the documentation of this file.

#ifndef PSO_H_
#define PSO_H_

#include <iostream>
#include <string>
#include <time.h>
#include <stdlib.h>
#include <vector>
#include <stack>
#include <map>
#include <math.h>
#include <set>
#include <queue>
#include <algorithm>

#include <fstream>
#include <sstream>

namespace pso{

    class Coordinate  {  
        public:  
            float x;  
            float y;  
            Coordinate()
            {
                x=0.0f;  
                y=.0f;  
            }
            
            Coordinate(float x,float y)
            {
                this->x=x;  
                this->y=y; 
            } 
    };
    
    class Particle{
        //friend: 
        //    std::ostream& operator<<(std::ostream &output,const Particle &right);  
  
        public:  
            Particle(float x,float y)
            {
                Xmax=30.0f;
                Xmin=0.0f;  
                Ymax=30.0f;  
                Ymin=0.0f;  
                Vxmax=Xmax-Xmin;
                Vxmin=0-Vxmax;  
                Vymax=Ymax-Ymin;  
                Vymin=0-Vymax;  
  
                c1=2.0f;  
                c2=2.0f;
    
                c.x=x;  
                c.y=y;  
                //p=100.0f;
                p=pow(c.x-10.0f,2)+pow(c.y-20.0f,2);  
                Vx=(Xmax-Xmin)/8.0f;
                Vy=(Xmax-Xmin)/8.0f;
      
                pBest.x=x;  
                pBest.y=y;
            }
            
            void setP()
            {
                float temp=pow(c.x-10.0f,2)+pow(c.y-20.0f,2);  
                if(temp<p)  
                {  
                    p=temp;  
                    //pBest.x=c.x;  
                    //pBest.y=c.y;  
                    pBest=c;  
                }  
            }
            
            float getP()const
            {
                return p;  
            }

            Coordinate getPBest()const
            {
                return pBest;  
            }

            void setV(Coordinate gBest,float w)
            {
                float r1,r2;  
                r1=rand()/(float)RAND_MAX;  
                r2=rand()/(float)RAND_MAX;  
                Vx=w*Vx+c1*r1*(pBest.x-c.x)+c2*r2*(gBest.x-c.x);  
                if(Vx>Vxmax)  
                    Vx=Vxmax;  
                else if(Vx<Vxmin)  
                    Vx=Vxmin;  
                Vy=w*Vy+c1*r1*(pBest.y-c.y)+c2*r2*(gBest.y-c.y);  
                if(Vy>Vxmax)  
                    Vy=Vxmax;  
                else if(Vy<Vxmin)  
                    Vy=Vxmin;  
            }
            
            float getVx()const
            {
                return Vx;
            }
            
            float getVy()const
            {
                return Vy;
            }
     
            void setCoordinate()
            {
                c.x=c.x+Vx;  
                if(c.x>Xmax)  
                    c.x=Xmax;  
                else if(c.x<Xmin)  
                    c.x=Xmin;  
                c.y=c.y+Vy;  
                if(c.y>Ymax)  
                    c.y=Ymax;  
                else if(c.y<Ymin)  
                    c.y=Ymin;
            }
            
            float getX()const
            {
                return c.x;  
            }
            
            float getY()const
            {
                return c.y;
            }
        private:  
            Coordinate c;  
            float p;
            Coordinate pBest;
            float Vx;  
            float Vy;  
            float Xmax,Xmin;  
            float Ymax,Ymin;  
            float Vxmax,Vxmin;
            float Vymax,Vymin;  
            float c1,c2;
    };
};
#endif