Searcher Class Reference

#include <Searcher.h>

Collaboration diagram for Searcher:

Public Member Functions
	Searcher ()
	Searcher (const Searcher &rhs)
	~Searcher ()
Searcher &	operator= (const Searcher &rhs)
bool	step (float dt)
void	evolve ()
void	startSearch (bool dostart=true)
bool	searchDone () const
template<class Iter >
unsigned int	getWinners (Iter iter) const
std::map< dword, Winner > &	getWinList ()
const std::map< dword, Winner > &	getWinList () const
float	getBestQOF () const
float	getLeastQOF () const
float	relativeQOF (float qof) const
const Winner *	getWinner (dword id) const
void	setExpectationMap (const ExpectationMap &em)
ExpectationMap &	getExpectationMap ()
const ExpectationMap &	getExpectationMap () const
void	clear ()
void	draw () const
bool	triggerTest (int mx, int my, int what)
	operator bool () const
const Model &	getRepresentative () const
void	reattachSensors ()
float	getGeneration (const Model *model) const
void	setShapeWeight (float shapeweight)
float	getShapeWeight () const

Protected Types
enum	{ MODE_PAUSE, MODE_RUN, MODE_DONE }

Protected Member Functions
std::map< dword, Winner > &	updateWinList ()
int	getBindex (int bx, int by, bool &culled=*((bool *) NULL)) const
int	getBindex (const PropVec &prop, bool &culled=*((bool *) NULL)) const
int	getBindex (const Model &model, bool &culled=*((bool *) NULL)) const
void	getQualityRange (float &lqof, float &hqof, float shapeweight=-1) const
void	findWinners ()
bool	buildBins (float bindist=0.f)
int	buildClusters ()
void	selectWinners ()
void	cleanFlags ()
std::list< Model * >::iterator &	remove (std::list< Model * >::iterator &mi)
int	add (Model *m)
Model &	mutate (Model &model, float rate=1) const
int	distribute (int n=-1, float qth=0, bool count=false)

Protected Attributes
Model	m_Representative
PropVec	m_AvgWinner
PropVec	m_StdWinner
PropVec	m_MinModel
PropVec	m_MaxModel
ExpectationMap	m_EMap
std::list< Model * >	m_Population
int	m_NPop
std::vector< MBin >	m_Bins
int	m_BinsX
int	m_BinsY
float	m_BinDist
std::list< MBin >	m_Clusters
int	m_NClusters
MBin *	m_CurCluster
float	m_Time
Point	m_PosMax
Point	m_PosMin
Point	m_PosRange
enum Searcher:: { ... }	SMode
dword	m_Mode
float	m_EvolveT
float	m_MutateRate
std::map< dword, Winner >	m_Winners
dword	m_NextWinID
float	m_ShapeWeight

Detailed Description

Engine performing genetic search to determine a set of local winners.

Definition at line 16 of file Searcher.h.

Member Enumeration Documentation

anonymous enum

protected

Enumerator
MODE_PAUSE
MODE_RUN
MODE_DONE

Definition at line 79 of file Searcher.h.

{ MODE_PAUSE, MODE_RUN, MODE_DONE } SMode;

Constructor & Destructor Documentation

Searcher::Searcher

(

)

Definition at line 76 of file Searcher.cpp.

References getSearchPara(), m_EvolveT, m_MutateRate, SearcherParams::m_MutateRate, m_ShapeWeight, and SearcherParams::m_ShapeWeight.

                   : m_NPop(0), m_Time(0), m_Mode(MODE_PAUSE),
                       m_NextWinID(Winner::WID_FIRST),
                       m_ShapeWeight(SRCH_SHAPEWEIGHT)
{
    m_EvolveT = 0.0f;
    m_MutateRate = getSearchPara().m_MutateRate;
    m_ShapeWeight = getSearchPara().m_ShapeWeight;
}

Searcher::Searcher

(

const Searcher &

rhs

)

Definition at line 85 of file Searcher.cpp.

References operator=().

{
    operator=(rhs);
}

Searcher::~Searcher

(

)

Definition at line 90 of file Searcher.cpp.

References clear().

{
    clear();
}

Member Function Documentation

int Searcher::add ( Model *  m )

protected

Definition at line 143 of file Searcher.cpp.

References Model::getFlags(), m_NPop, m_Population, m_Time, Model::m_TimeStamp, Model::setID(), Model::setInstCount(), and Winner::WID_EMPTY.

Referenced by distribute(), evolve(), and getShapeWeight().

                          {
    m->m_TimeStamp = m_Time;
    m->getFlags() = 0;
    m->setID(Winner::WID_EMPTY);
    m->setInstCount(1);
    m_Population.push_back(m);
    return ++m_NPop;
}

bool Searcher::buildBins ( float  bindist = 0.f )

protected

Definition at line 361 of file Searcher.cpp.

References getBindex(), Model::getNNodes(), Model::getProperties(), getPropScale(), ExpectationMap::getRepresentative(), getSearchPara(), m_AvgWinner, m_BinDist, m_Bins, m_BinsX, m_BinsY, m_EMap, m_MaxModel, m_MinModel, m_Population, m_PosRange, SearcherParams::m_RelBinDist, m_Representative, m_ShapeWeight, m_StdWinner, MAXRAD, Model::ST_MEMBER, Point2D::sum(), Point2D::x, and Point2D::y.

Referenced by buildClusters(), and getShapeWeight().

{
    if(m_EMap.getRepresentative().getNNodes() == 0) return false;
    else if(m_Representative.getNNodes() == 0) {
        m_Representative = m_EMap.getRepresentative();
        m_AvgWinner = m_Representative.getProperties();
        m_StdWinner = 0.f;
        m_MinModel = m_MaxModel = m_AvgWinner;
    }
//destroy bins
    m_BinsX = m_BinsY = 0;
    m_Bins.clear();
//initialize bins
    float radius = getPropScale(m_MinModel);
    //m_Representative.getStdRadius();
    if(m_Population.empty() || m_PosRange.sum()==0 || radius<0.001)
        return false;

    m_BinDist = bindist != 0.f ? bindist : radius*getSearchPara().m_RelBinDist;
    m_BinsX = (int)(m_PosRange.x/m_BinDist)+1;
    m_BinsY = (int)(m_PosRange.y/m_BinDist)+1;
    m_Bins.resize(m_BinsX*m_BinsY);
//          cout << m_PosRange << endl;
//          TRACE("created " << m_BinsX << " in X and " << m_BinsY
//                << " in Y direction.");
//fill bins
    for(list<Model*>::iterator model = m_Population.begin();
        model != m_Population.end(); model++)
    {
        (*model)->setOldState();
        (*model)->unsetFlags(Model::ST_MEMBER);
        (*model)->setShapeWeight(m_ShapeWeight);
        Point c = (*model)->getCenter();
        int bx = (int)(c.x/m_BinDist);
        int by = (int)(c.y/m_BinDist);
#define MAXRAD 0
#if (MAXRAD>0)
        for(int px=bx-MAXRAD; px<=bx+MAXRAD; px++) {
            if(px>=0 && px<=m_BinsX) {
                for(int py=by-MAXRAD; py<=by+MAXRAD; py++) {
                    bool culled;
                    int index = getBindex(px,py,culled);
                    if(!culled)
                        m_Bins[index].push_back(*model);
                }
            }
        }
#else
        bool culled;
        int index = getBindex(bx,by,culled);
        //if(!culled)
        m_Bins[index].push_back(*model);
#endif
#undef MAXRAD
    }
    return true;
}

int Searcher::buildClusters ( )

protected

Definition at line 419 of file Searcher.cpp.

References buildBins(), Model::DIST_CPOINTS, getBindex(), Model::getDataScale(), getPropDir(), getPropPos(), getPropScale(), getSearchPara(), m_BinDist, m_Bins, m_BinsX, SearcherParams::m_ClusterDDir, SearcherParams::m_ClusterDPos, SearcherParams::m_ClusterDScale, SearcherParams::m_ClusterMeltDist, m_Clusters, SearcherParams::m_ClusterTH, m_CurCluster, m_NClusters, SearcherParams::m_NClusters, M_PI, m_Population, m_Representative, mapAnglePI(), Model::ST_MEMBER, Point2D::x, and Point2D::y.

Referenced by evolve(), and getShapeWeight().

{
    m_Clusters.clear();
    m_NClusters = 0;
    if(!buildBins()) return 0;
    list<Model*>::iterator model = m_Population.begin();
    float cqth = (*model)->getQualityOfFit()*getSearchPara().m_ClusterTH;
    float m_MergeDistMM = getSearchPara().m_ClusterMeltDist;
    float m_MergeDist;
    if(m_Representative.getDataScale()>0)
        m_MergeDist = m_Representative.getDataScale()*m_MergeDistMM;
    else m_MergeDist = m_MergeDistMM*100;
    int nmelt = 0, nmerge = 0;
    int maxclusters = (int)getSearchPara().m_NClusters;
    if(maxclusters == 0) maxclusters = numeric_limits<int>::max();
    while(model != m_Population.end()
          && (*model)->getQualityOfFit()>cqth
          && m_NClusters < maxclusters)
    {
        if(!(*model)->hasFlags(Model::ST_MEMBER)) {
//create new cluster from model
            m_Clusters.push_back(MBin());
            m_CurCluster = &m_Clusters.back();
            m_CurCluster->push_back(*model);
            (*model)->setFlags(Model::ST_MEMBER);
            PropVec cprop = (*model)->getPropertiesMM();
            float mdrot = M_PI*getSearchPara().m_ClusterDDir;
            float mdscale = getSearchPara().m_ClusterDScale;
            float mdpos = getPropScale(cprop)*getSearchPara().m_ClusterDPos;
            m_NClusters++;
//scan bins for other cluster members
            Point c = (*model)->getCenter();
            int bx = (int)(c.x/m_BinDist);
            int by = (int)(c.y/m_BinDist);
            int binradius = (int)ceil(mdpos/m_BinDist);
            for(int px=bx-binradius; px<=bx+binradius; px++) {
                if(px>=0 && px<=m_BinsX) {
                    for(int py=by-binradius; py<=by+binradius; py++) {
                        bool culled;
                        int index = getBindex(px,py,culled);
                        if(!culled) {
                            MBin::iterator be = m_Bins[index].begin();
                            while(be != m_Bins[index].end()) {
                                MBin::iterator nextbe = be;
                                nextbe++;
                                if(!(*be)->hasFlags(Model::ST_MEMBER)) {
                                    PropVec prop = (*be)->getPropertiesMM();
                                    //PropVec pdiff = getPropTF(cprop, prop);
                                    float dpos = (getPropPos(cprop)-
                                                  getPropPos(prop)).norm();
                                    float drot = mapAnglePI(getPropDir(cprop)-
                                                            getPropDir(prop));
                                    drot = fabs(drot);
                                    float dscale = getPropScale(prop)/
                                        getPropScale(cprop);
                                    if(dscale>1) dscale = 1-1/dscale;
                                    else dscale = 1-dscale;
                                    if(dpos < mdpos && drot < mdrot &&
                                       dscale < mdscale) {
                                        if(dpos < m_MergeDistMM &&
                                           (*model)->distance(
                                               **be,Model::DIST_CPOINTS)
                                           < m_MergeDist)
                                        {
                                            //too close --> melt
                                            (*model)->mergeModel(**be);
                                            nmelt++;
                                        } else {
                                            m_CurCluster->push_back(*be);
                                            nmerge++;
                                        }
                                        (*be)->setFlags(Model::ST_MEMBER);
                                        m_Bins[index].erase(be);
                                    }
                                } else m_Bins[index].erase(be);
                                be = nextbe;
                            }
                        }
                    }
                }
            }
//             DUMP(cprop);
//             DUMP((*model)->getQualityOfFit());
//             DUMP(m_CurCluster->size());
        }
        model++;
    }
//    DUMP(nmelt);
//    DUMP(m_MergeDist);
//    DUMP(nmerge);
//    DUMP(m_NClusters);
    return m_NClusters;
}

void Searcher::cleanFlags ( )

protected

Definition at line 546 of file Searcher.cpp.

References VVector< T, D >::clampLB(), VVector< T, D >::clampUB(), DUMP, Model::getProperties(), Model::getQualityOfFit(), m_AvgWinner, m_MaxModel, m_MinModel, m_Population, m_Representative, m_StdWinner, m_Time, Model::m_TimeStamp, VVector< T, D >::sqrtEach(), Model::ST_DEL, Model::ST_LOOSER, Model::ST_MEMBER, Model::ST_NODEL, Model::ST_OLDSTATE, and Model::ST_WINNER.

Referenced by evolve(), and getShapeWeight().

{
//remove loosers -- no, just set flags properly
    int killcount = 0;
    int wincount = 0;
    int mergekill=0;
    int lowkill=0;
    Model *prep = *m_Population.begin();
    m_AvgWinner = 0.f;
    m_StdWinner = 0.f;
    m_MinModel = m_MaxModel = prep->getProperties();
    list<Model*>::iterator model = m_Population.begin();
    while(model != m_Population.end())
    {
        list<Model*>::iterator nm = model; nm++;
        if((*model)->hasFlags(Model::ST_NODEL)) {
            (*model)->setFlags(Model::ST_WINNER|Model::ST_MEMBER);
            (*model)->unsetFlags(Model::ST_LOOSER|Model::ST_OLDSTATE
                                 |Model::ST_DEL);
        }
        if(!(*model)->hasFlags(Model::ST_MEMBER)) {
            remove(model);
            lowkill++;
        } else if((*model)->hasFlags(Model::ST_DEL)) {
            //(*model)->unsetFlags(Model::ST_DEL);
            remove(model);
            mergekill++;
        } else {
            m_MinModel.clampUB((*model)->getProperties());
            m_MaxModel.clampLB((*model)->getProperties());
            if((*model)->isOldState()) {
                (*model)->unsetFlags(Model::ST_WINNER|Model::ST_LOOSER
                                     |Model::ST_OLDSTATE);
                //(*model)->m_TimeStamp[Model::TS_WIN] = 0.0;
            } else if((*model)->isWinner()) {
                if(prep->getQualityOfFit() < (*model)->getQualityOfFit())
                    prep = *model;
                PropVec winprop = (*model)->getProperties();
                m_AvgWinner += winprop;
                m_StdWinner += (winprop *= winprop);
                wincount++;
            } else { //if((*model)->isLooser()) {
                if(!(*model)->isLooser())
                    (*model)->setLooser(true, m_Time);
                //(*model)->m_TimeStamp[Model::TS_WIN] = 0.0;
                killcount++;
            }
        }
        model = nm;
    }
    m_Representative = *prep;
    if(!wincount) {
        m_AvgWinner = m_Representative.getProperties();
        m_StdWinner = 0.f;
    } else {
        m_AvgWinner /= (float)(wincount);
        m_StdWinner /= (float)(wincount);
        DUMP(m_AvgWinner);
        DUMP(m_StdWinner);
        m_StdWinner -= (m_AvgWinner*m_AvgWinner);
        m_StdWinner.sqrtEach();
    }
    DUMP(mergekill);
    DUMP(lowkill);
    cout << "representative age: "
         << m_Time-m_Representative.m_TimeStamp << " s" //[Model::TS_WIN]
         << " (search time "<<m_Time<<" s)"<<endl;
    cout << killcount<<" loosers and " << wincount << " winners."<<endl;
}

void Searcher::clear

(

)

Definition at line 126 of file Searcher.cpp.

References Model::clear(), ExpectationMap::clear(), m_Bins, m_BinsX, m_BinsY, m_EMap, m_EvolveT, m_NPop, m_Population, m_Representative, m_Time, and m_Winners.

Referenced by getExpectationMap(), operator=(), startSearch(), triggerTest(), and ~Searcher().

                     {
    m_BinsX = m_BinsY = 0;
    m_Bins.clear();
    for(list<Model*>::iterator gi=m_Population.begin();
        gi != m_Population.end(); gi++)
    {
        delete *gi;
    }
    m_Population.clear();
    m_Representative.clear();
    m_EMap.clear();
    m_Winners.clear();
    m_NPop=0;
    m_Time=0;
    m_EvolveT=0;
}

int Searcher::distribute ( int  n = -1, float  qth = 0, bool  count = false  )

protected

Definition at line 627 of file Searcher.cpp.

References add(), ExpectationMap::generateInstance(), Model::getNNodes(), Model::getProperties(), Model::getQualityOfFit(), ExpectationMap::getRepresentative(), m_AvgWinner, m_EMap, m_Representative, and m_StdWinner.

Referenced by getShapeWeight().

{
    //this function is unused
    if(m_EMap.getRepresentative().getNNodes() == 0) return -1;
    else if(m_Representative.getNNodes() == 0) {
        m_Representative = m_EMap.getRepresentative();
        m_AvgWinner = m_Representative.getProperties();
        m_StdWinner = 0.f;
    }
    for(int i=0; i<n; i++) {
        Model *newmod = m_EMap.generateInstance();
        if(newmod->getQualityOfFit() < qth) {
            delete newmod;
        } else {
            //newmod->m_TimeStamp = m_Time; //[Model::TS_CREATE]
            add(newmod);
        }
    }
    return n;
}

void Searcher::draw

(

)

const

Definition at line 687 of file Searcher.cpp.

References Model::draw(), m_Population, m_Representative, and m_Winners.

Referenced by Brain::drawAllModels(), and getExpectationMap().

{
    glLineWidth(1.0f);
    for(list<Model*>::const_iterator m = m_Population.begin();
        m!=m_Population.end(); m++)
    {
        if((*m)->isWinner()) {
            glColor4f(0.1,0.9,0.0,0.7);
        } else if((*m)->isLooser()) {
            glColor4f(0.0,0.0,1.0,0.3);
        } else {
            glColor4f(0.9,0.9,0.0,0.3);
        }
        (*m)->draw();
    }
    glLineWidth(3.0f);
    glColor4f(0.1,0.9,0.0,1.0);
    for(list<Model*>::const_iterator m = m_Population.begin();
        m!=m_Population.end(); m++)
    {
        if((*m)->isWinner())// && (m_Time-(*m)->m_TimeStamp[Model::TS_WIN])>6)
            (*m)->draw();
    }
    if(!m_Winners.empty()) {
        glLineWidth(3.0f);
        glColor4f(1.0f, 0.0f, 0.5f,1.0f);
        m_Representative.draw();
        glLineWidth(1.0f);
    }
}

void Searcher::evolve

(

)

Definition at line 163 of file Searcher.cpp.

References add(), buildClusters(), cleanFlags(), DUMP, ExpectationMap::generateInstance(), Model::getName(), Model::getQualityOfFit(), getQualityRange(), getSearchPara(), m_EMap, SearcherParams::m_EvolveCycle, EMDistribution::m_Integral, SearcherParams::m_MaxPop, m_Mode, m_MutateRate, SearcherParams::m_MutateSpawns, SearcherParams::m_MutateTHRed, m_NextWinID, m_NPop, SearcherParams::m_NSpawns, SearcherParams::m_NSpawnsTHRed, m_Population, m_Representative, m_Time, Winner::m_WinnerID, m_Winners, MODE_DONE, MODE_PAUSE, mutate(), NULL, ExpectationMap::ratePropVec(), selectWinners(), and Model::ST_NODEL.

Referenced by Brain::evolve().

{
    if(m_Mode == MODE_PAUSE) return;
//create, mutate, and remove
    int extrakill=0;
    float lqof,hqof;
    getQualityRange(lqof,hqof);
    double slowlive=0.0;
    if(m_NPop) {
        for(list<Model*>::const_iterator m = m_Population.begin();
            m!=m_Population.end(); m++)
        {
            //if((*m)->m_TimeStamp-m_Time > 4&&(*m)->getLiveliness()>slowlive)
            slowlive += (*m)->getLiveliness();
        }
        slowlive /= m_NPop;
        slowlive *= 0.5;
        DUMP(slowlive);
    }

    //findWinners();
    if(buildClusters()) {
        selectWinners();
        cleanFlags();
    }
    //float kill_quality_th = hqof*0.7;
    list<Model*>::iterator m=m_Population.begin();
    dword rank = 0;
    bool pastlast=false;
    int lamekill=0;
    m_Winners.clear();
    Model* lastmodel = !m_Population.empty() ? m_Population.back():NULL;
    while(m != m_Population.end() && !pastlast)
    {
        if(*m == lastmodel) pastlast=true;
        list<Model*>::iterator nm = m; nm++;
        //float relq = (hqof-lqof)*kill_quality_th+lqof;
        //(hqof!=0.0) ? ((*m)->getQualityOfFit()-lqof)/hqof :1;
        //if(relq > (*m)->getQualityOfFit() && m_NPop>1) {
        if(rank > getSearchPara().m_MaxPop) {
            if(m_NPop>1) { remove(m); extrakill++; }
        } else if((*m)->isWinner()) {
            PropVec propvec((*m)->getProperties());
            if(!(*m)->getID()) (*m)->setID(m_NextWinID++);
            Winner winner(*m);
            float rating = m_EMap.ratePropVec(propvec, &winner);
            if(rating < getSearchPara().m_RatingTH &&
               !(*m)->hasFlags(Model::ST_NODEL)) {
//                cout << "removing invalid winner " << endl;
//                     DUMP(rating);
//                     DUMP(propvec);
//                     DUMP(propvec.clamp(m_EMap.m_LB, m_EMap.m_UB));
//                     DUMP((*m)->getName());
                remove(m);
                m_NextWinID--;
            } else
            {
                m_Winners[winner.m_WinnerID] = winner;
//                 m_Winners.insert(pair<dword,Winner>(winner.m_WinnerID,
//                                                     winner));
//mutate winners
                float threduce = getSearchPara().m_MutateTHRed;
                float qth = (*m)->getQualityOfFit()*threduce;
                int cs=0;
                int misses=0;
                const int nspawns = getSearchPara().m_MutateSpawns;
                while(cs<nspawns) {
                    Model *newmod = &mutate(*(new Model(**m)),m_MutateRate
                                            *exp((m_Time/getSearchPara().m_MutateHL)
                                                 *(-M_LN2)));
                    if(newmod->getQualityOfFit() < qth) {
                        delete newmod;
                        misses++;
                        if(misses%nspawns==0) qth*=threduce;
                    } else {
                        add(newmod);
                        cs++;
                    }
                }
                if(misses>nspawns) DUMP(misses)<<" for mutation"<<endl;
                //nm = m; nm++; // ensure validity of iterator (?)
            }
        } else if((*m)->getLiveliness()<slowlive) {
            remove(m);
            lamekill++;
        } else if(m_NPop>1 && (*m)->isLooser() &&
                  (m_Time-(*m)->m_TimeStamp>getSearchPara().m_EvolveCycle*10))
        {
            remove(m);
        }
        m = nm;
        rank++;
    }
//    DUMP(extrakill);
//    DUMP(lamekill);
//Spawn new instances
    int cs = 0;
    float threduce = getSearchPara().m_NSpawnsTHRed;
    float qth = hqof*threduce; //DEBUG
    int misses = 0;
    const int nspawns = m_EMap && m_EMap.m_Integral > 0.00001f
        ? getSearchPara().m_NSpawns : 0;
    while(cs<nspawns) {
        Model *newmod = m_EMap.generateInstance();
        if(newmod->getQualityOfFit() < qth) {
            delete newmod;
            misses++;
            if(misses%nspawns==0) qth*=threduce;
        } else {
            //qth = newmod->getQualityOfFit();
            //newmod->m_TimeStamp = m_Time; //[Model::TS_CREATE]
            add(newmod);
            cs++;
        }
    }
    //if(misses>20) DUMP(misses) << " for distribution" << endl;
    m_Population.sort( std::greater<Model*>() );
    if(m_NPop > 0 && //(int)m_Winners.size() &&
       m_EMap.m_Integral < 0.0001f)
    {
        m_Mode = MODE_DONE;
    } else cout << m_Representative.getName() << " searching, integral = "
                << m_EMap.m_Integral << endl;
}

void Searcher::findWinners ( )

protected

Referenced by getShapeWeight().

float Searcher::getBestQOF ( ) const

inline

Definition at line 129 of file Searcher.h.

References m_Population.

Referenced by getWinList(), and relativeQOF().

{
    return m_Population.empty()? 1.f
        :(*m_Population.begin())->getQualityOfFit();
}

int Searcher::getBindex ( int  bx, int  by, bool &  culled = *((bool*)NULL)  ) const

inlineprotected

Definition at line 104 of file Searcher.h.

References m_BinsX, m_BinsY, and NULL.

Referenced by buildBins(), buildClusters(), getBindex(), and getShapeWeight().

{
    bool tb;
    bool &cf = &culled != NULL ? culled : tb; // redirect to temporary bool?
    cf = false;
    if(bx<0) { bx=0; cf = true; }
    else if(bx>=m_BinsX) { bx=m_BinsX-1; cf = true; }
    if(by<0) { by=0; cf = true; }
    else if(by>=m_BinsY) { by=m_BinsY-1; cf = true; }
    return by*m_BinsX+bx;
}

int Searcher::getBindex ( const PropVec &  prop, bool &  culled = *((bool*)NULL)  ) const

inlineprotected

Definition at line 116 of file Searcher.h.

References getBindex().

{
    return getBindex((int)prop[0], (int)prop[1], culled);
}

int Searcher::getBindex ( const Model &  model, bool &  culled = *((bool*)NULL)  ) const

inlineprotected

Definition at line 121 of file Searcher.h.

References getBindex(), Model::getCenter(), and setPropPos().

{
    //PropVec prop=model.getProperties();
    PropVec prop(0.);
    setPropPos(prop, model.getCenter());
    return getBindex(prop, culled);
}

ExpectationMap& Searcher::getExpectationMap ( )

inline

Definition at line 37 of file Searcher.h.

References m_EMap.

Referenced by MStructure::rebuildExpMap(), and Brain::setupSearch().

{ return m_EMap; }

const ExpectationMap& Searcher::getExpectationMap ( ) const

inline

Definition at line 38 of file Searcher.h.

References clear(), draw(), m_EMap, and triggerTest().

{ return m_EMap; }

float Searcher::getGeneration

(

const Model *

model

)

const

Definition at line 303 of file Searcher.cpp.

References getSearchPara(), SearcherParams::m_EvolveCycle, m_Time, and Model::m_TimeStamp.

Referenced by MStructure::addExpectation(), and getRepresentative().

                                                      {
    return (m_Time - model->m_TimeStamp) / getSearchPara().m_EvolveCycle;
}

float Searcher::getLeastQOF ( ) const

inline

Definition at line 135 of file Searcher.h.

References m_Population.

Referenced by getWinList(), and relativeQOF().

{
    return m_Population.empty()? 0.f
        :(*m_Population.rbegin())->getQualityOfFit();
}

void Searcher::getQualityRange ( float &  lqof, float &  hqof, float  shapeweight = -1  ) const

protected

Definition at line 649 of file Searcher.cpp.

References m_Population, and setShapeWeight().

Referenced by evolve(), getShapeWeight(), and triggerTest().

{
    if(m_Population.empty()) {
        lqof = hqof = 0;
        return;
    }
    bool cw = (shapeweight!=-1);
    if(cw) (*m_Population.begin())->setShapeWeight(shapeweight);
    lqof=hqof=(*m_Population.begin())->getQualityOfFit();
    for(list<Model*>::const_iterator m = m_Population.begin();
        m!=m_Population.end(); m++)
    {
        if(cw) (*m)->setShapeWeight(shapeweight);
        if((*m)->getQualityOfFit()>hqof) hqof=(*m)->getQualityOfFit();
        if((*m)->getQualityOfFit()<lqof) lqof=(*m)->getQualityOfFit();
    }
}

const Model& Searcher::getRepresentative ( ) const

inline

Definition at line 43 of file Searcher.h.

References getGeneration(), m_Representative, and reattachSensors().

Referenced by Brain::triggerTest().

{ return m_Representative; }

float Searcher::getShapeWeight ( ) const

inline

Definition at line 47 of file Searcher.h.

References add(), buildBins(), buildClusters(), cleanFlags(), distribute(), findWinners(), getBindex(), getQualityRange(), m_ShapeWeight, mutate(), NULL, selectWinners(), and updateWinList().

Referenced by MStructure::write().

{ return m_ShapeWeight; }

std::map<dword,Winner>& Searcher::getWinList ( )

inline

Definition at line 30 of file Searcher.h.

References m_Winners.

Referenced by MStructure::addExpectation(), StructTable::findBestConnection(), and MStructure::verifyWinnerRating().

{ return m_Winners; }

const std::map<dword,Winner>& Searcher::getWinList ( ) const

inline

Definition at line 31 of file Searcher.h.

References getBestQOF(), getLeastQOF(), getWinner(), m_Winners, relativeQOF(), and setExpectationMap().

{ return m_Winners; }

const Winner * Searcher::getWinner

(

dword

id

)

const

Definition at line 668 of file Searcher.cpp.

References m_Winners, and NULL.

Referenced by getWinList(), MStructure::getWinner(), and MStructure::verifyWinnerRating().

{
    map<dword,Winner>::const_iterator wi = m_Winners.find(id);
    if(wi == m_Winners.end()) return NULL;
    else return &wi->second;
}

template<class Iter >

unsigned int Searcher::getWinners ( Iter  iter ) const

inline

Definition at line 90 of file Searcher.h.

References m_Population.

Referenced by searchDone(), and Brain::triggerTest().

{
    unsigned int nwin=0;
    for(std::list<Model*>::const_iterator wi=m_Population.begin();
        wi != m_Population.end(); wi++)
    {
        if((*wi)->isWinner()) {
            *iter++ = *wi;
            nwin++;
        }
    }
    return nwin;
}

Model & Searcher::mutate ( Model &  model, float  rate = 1  ) const

protected

Definition at line 307 of file Searcher.cpp.

References Model::adaptProperties(), Model::adaptProportion(), Model::addNoise(), frand, FRAND1, Model::getProperties(), getSearchPara(), Model::getStdRadius(), M_PI, Model::push(), Model::pushRotate(), setPropDir(), and setPropPos().

Referenced by evolve(), and getShapeWeight().

{
#define _PROP_MUTATION_
#ifdef _PROP_MUTATION_
    PropVec prop = model.getProperties();
    PropVec mutation(0.f);
    bool same=true;
    while(same) {
        if(FRAND1 < getSearchPara().m_MutatePDir){
            setPropDir(mutation,frand(2*M_PI));
            same = false;
        }
        if(FRAND1 < getSearchPara().m_MutatePPos) {
            Point pos(0,0);
            float radius = model.getStdRadius();//*rate;
            pos += Point2D(radius-frand(2*radius), radius-frand(2*radius));
            setPropPos(mutation,pos);
            same = false;
        }
        if(FRAND1 < getSearchPara().m_MutatePNoise) {
            model.addNoise(getSearchPara().m_MutateNoiseRate*rate);
            same = false;
        }
        if(FRAND1 < getSearchPara().m_MutatePProp) {
            model.adaptProportion(getSearchPara().m_MutatePropRate);
            same = false;
        }
    }
    model.adaptProperties(prop+(mutation*rate));
#else
    float radius=model.getStdRadius();
    model.push(Point2D(-radius+frand(2*radius),
                       -radius+frand(2*radius)));
    model.pushRotate((*m)->getCenter(), -2+frand(4));
    model.addNoise(0.1);
#endif
    return model;
}

Searcher::operator bool ( ) const

inline

Definition at line 42 of file Searcher.h.

References m_EMap.

{ return (bool)m_EMap; }

Searcher & Searcher::operator=

(

const Searcher &

rhs

)

Definition at line 95 of file Searcher.cpp.

References clear(), m_AvgWinner, m_BinDist, m_Bins, m_BinsX, m_BinsY, m_EMap, m_EvolveT, m_Mode, m_MutateRate, m_NextWinID, m_NPop, m_Population, m_PosMax, m_PosMin, m_PosRange, m_Representative, m_ShapeWeight, m_StdWinner, m_Time, m_Winners, and updateWinList().

Referenced by Searcher().

{
    if(&rhs == this) return *this;
    clear();
    m_Representative = rhs.m_Representative;
    m_AvgWinner =  rhs.m_AvgWinner;
    m_StdWinner =  rhs.m_StdWinner;
    m_EMap = rhs.m_EMap;
    for(list<Model*>::const_iterator gi=rhs.m_Population.begin();
        gi != rhs.m_Population.end(); gi++)
    {
        m_Population.push_back(new Model(**gi));
    }
    m_NPop = rhs.m_NPop;
    m_Bins = rhs.m_Bins;
    m_BinsX, m_BinsY = rhs.m_BinsX;
    m_BinDist = rhs.m_BinDist;
    m_Time = rhs.m_Time;
    m_PosMax = rhs.m_PosMax;
    m_PosMin = rhs.m_PosMin;
    m_PosRange = rhs.m_PosRange;
    m_Mode = rhs.m_Mode;
    m_EvolveT = rhs.m_EvolveT;
    m_MutateRate = rhs.m_MutateRate;
    m_NextWinID = rhs.m_NextWinID;
    m_Winners = m_Winners;
    m_ShapeWeight = rhs.m_ShapeWeight;
    updateWinList();
    return *this;
}

void Searcher::reattachSensors

(

)

Definition at line 616 of file Searcher.cpp.

References ExpectationMap::getRepresentative(), m_EMap, m_Population, m_Representative, and Model::reattachSensors().

Referenced by getRepresentative().

{
    m_EMap.getRepresentative().reattachSensors();
    m_Representative.reattachSensors();
    for(list<Model*>::iterator model = m_Population.begin();
        model != m_Population.end(); model++)
    {
        (*model)->reattachSensors();
    }
}

float Searcher::relativeQOF ( float  qof ) const

inline

Definition at line 141 of file Searcher.h.

References getBestQOF(), and getLeastQOF().

Referenced by getWinList().

{
    const float mq = getBestQOF(), lq = getLeastQOF();
    float range = mq-lq; if(range <= 0.f) range = 1.f;
    return (qof-lq)/range;
}

list< Model * >::iterator & Searcher::remove ( std::list< Model * >::iterator &  mi )

protected

Definition at line 152 of file Searcher.cpp.

References m_NPop, m_Population, and Model::ST_NODEL.

{
    if(!(*mi)->hasFlags(Model::ST_NODEL)) {
        list<Model*>::iterator ci = mi++;
        delete *ci;
        m_Population.erase(ci);
        m_NPop--;
    }
    return mi;
}

bool Searcher::searchDone ( ) const

inline

Definition at line 28 of file Searcher.h.

References getWinners(), m_Mode, and MODE_DONE.

{ return m_Mode == MODE_DONE; }

void Searcher::selectWinners ( )

protected

Definition at line 513 of file Searcher.cpp.

References m_Clusters, m_Time, Model::ST_DEL, and TRACE.

Referenced by evolve(), and getShapeWeight().

{
    dword m_NBinWinners = 1;
    for(list< MBin >::iterator cluster = m_Clusters.begin();
        cluster != m_Clusters.end(); cluster++) {
        if(!cluster->empty()) {
            MBin::iterator crep = cluster->begin();
//select winners
            if(!(*crep)->hasFlags(Model::ST_DEL)) {
                (*crep)->setOldState(false);
                if(!(*crep)->isWinner()) {
//                     float time = m_Time;
//                     if((*crep)->m_TimeStamp[Model::TS_WIN]!=0)
//                         time = (*crep)->m_TimeStamp[Model::TS_WIN];
                    (*crep)->setWinner(true); //, time);
                }
                (*crep)->setLooser(false);
                crep++;
            } else  TRACE("DELETED CLUSTER WINNER????????");
//select rest as loosers
            while(crep != cluster->end()) {
                //if((*crep)->isOldState()) {
                (*crep)->setOldState(false);
                if((*crep)->isWinner()) (*crep)->setWinner(false);
                if(!(*crep)->isLooser()) {
                    (*crep)->setLooser(true, m_Time);
                }
                crep++;
            }
        }
    } // for each cluster
}

void Searcher::setExpectationMap

(

const ExpectationMap &

em

)

Definition at line 346 of file Searcher.cpp.

References ExpectationMap::correctLBUB(), EMDRect::getLB(), getPropPos(), EMDRect::getUB(), m_EMap, m_PosMax, m_PosMin, m_PosRange, EMDRect::setLB(), EMDRect::setUB(), and ExpectationMap::updateIntegral().

Referenced by getWinList(), main(), MStructure::rebuildExpMap(), and Brain::setupSearch().

{
    if(&em != &m_EMap) m_EMap = em;
    PropVec ub = m_EMap.getUB();
    PropVec lb = m_EMap.getLB();
    ExpectationMap::correctLBUB(lb,ub);
    m_EMap.setLB(lb); m_EMap.setUB(ub);
    m_PosMax = getPropPos(ub);
    m_PosMin = getPropPos(lb);
    //cout << "pos max=" << m_PosMax << "  pos min=" << m_PosMin << endl;
    m_PosRange = m_PosMax-m_PosMin;
    m_EMap.updateIntegral();

}

void Searcher::setShapeWeight ( float  shapeweight )

inline

Definition at line 46 of file Searcher.h.

References m_ShapeWeight.

Referenced by getQualityRange(), and MStructure::read().

{ m_ShapeWeight = shapeweight; }

void Searcher::startSearch

(

bool

dostart = true

)

Definition at line 718 of file Searcher.cpp.

References clear(), m_Mode, MODE_PAUSE, MODE_RUN, and updateWinList().

{
    if(dostart) {
        cout << "starting searcher..." << endl;
        clear();
        m_Mode = MODE_RUN;
        updateWinList();
    } else m_Mode = MODE_PAUSE;
}

bool Searcher::step

(

float

dt

)

Definition at line 288 of file Searcher.cpp.

References m_EMap, m_Mode, m_Population, m_Time, MODE_DONE, and MODE_PAUSE.

Referenced by Brain::evolve(), and MStructure::stepSearch().

{
    if(!m_EMap) return true;
    if(m_Mode == MODE_PAUSE) return false;
    else if(m_Mode == MODE_DONE) return true;

    m_Time+=dt;
    for(list<Model*>::iterator m=m_Population.begin();
        m != m_Population.end(); m++)
    {
        (*m)->updateParticles(dt);
    }
    return m_Mode==MODE_DONE; // not yet done
}

bool Searcher::triggerTest	(	int	mx,
		int	my,
		int	what
	)

Definition at line 728 of file Searcher.cpp.

References clear(), Model::getName(), getQualityRange(), SearcherParams::global, m_EMap, EMDistribution::m_Integral, m_Mode, m_Population, m_Representative, m_Time, MODE_DONE, MODE_PAUSE, MODE_RUN, and updateWinList().

Referenced by getExpectationMap(), and Brain::triggerTest().

{
    switch(what)
    {
    case KEY_r:
        clear();
        break;
    case KEY_s:
        if(m_Mode == MODE_PAUSE || m_Mode == MODE_DONE) {
            m_Mode = MODE_RUN;
            cout << "run" << endl;
        } else {
            m_Mode = MODE_PAUSE;
            cout << "pause" << endl;
        }
        break;
    case KEY_h:
        cout << m_Representative.getName() <<
            (m_Mode & (MODE_DONE|MODE_PAUSE)
             ? "is done " : "is busy ") << m_EMap.m_Integral << endl;
        m_Mode = MODE_PAUSE;
        cout << "now set to rest" << endl;
        break;
    case KEY_w:
    {
        list<Model*>::iterator model = m_Population.begin();
        while(model != m_Population.end())
        {
            list<Model*>::iterator nm = model; nm++;
            if(!(*model)->isWinner()) {
                remove(model);
            } else {
                cout << "winner at " << (*model)->getCenter() << " age "
                     << m_Time-(*model)->m_TimeStamp<<" s "
                     << "quality= " << (*model)->getQualityOfFit()
                     << " nmerges = " << (*model)->getInstCount()
                     << " ID = " << (*model)->getID()
                     << endl;
            }
            model = nm;
        }
    }
    break;
    case KEY_F4:
    {
        float lqof,hqof;
        getQualityRange(lqof,hqof);
        float qth = (lqof+hqof)*0.5;
        list<Model*>::iterator model = m_Population.begin();
        while(model != m_Population.end())
        {
            list<Model*>::iterator nm = model; nm++;
            if((*model)->getQualityOfFit() < qth) {
                remove(model);
            }
            model = nm;
        }
    }
    break;
    default:
        return false;
    }
    updateWinList();
    return true;
}

std::map< dword, Winner > & Searcher::updateWinList ( )

protected

Definition at line 675 of file Searcher.cpp.

References m_Population, and m_Winners.

Referenced by getShapeWeight(), operator=(), startSearch(), and triggerTest().

{
    m_Winners.clear();
    for(list<Model*>::iterator m = m_Population.begin();
        m!=m_Population.end(); m++)
    {
        if((*m)->isWinner())
            m_Winners[(*m)->getID()] = Winner(*m);
    }
    return m_Winners;
}

Member Data Documentation

PropVec Searcher::m_AvgWinner

protected

Definition at line 66 of file Searcher.h.

Referenced by buildBins(), cleanFlags(), distribute(), and operator=().

float Searcher::m_BinDist

protected

Definition at line 73 of file Searcher.h.

Referenced by buildBins(), buildClusters(), and operator=().

std::vector< MBin > Searcher::m_Bins

protected

Definition at line 71 of file Searcher.h.

Referenced by buildBins(), buildClusters(), clear(), and operator=().

int Searcher::m_BinsX

protected

Definition at line 72 of file Searcher.h.

Referenced by buildBins(), buildClusters(), clear(), getBindex(), and operator=().

int Searcher::m_BinsY

protected

Definition at line 72 of file Searcher.h.

Referenced by buildBins(), clear(), getBindex(), and operator=().

std::list< MBin > Searcher::m_Clusters

protected

Definition at line 74 of file Searcher.h.

Referenced by buildClusters(), and selectWinners().

MBin* Searcher::m_CurCluster

protected

Definition at line 76 of file Searcher.h.

Referenced by buildClusters().

ExpectationMap Searcher::m_EMap

protected

Definition at line 68 of file Searcher.h.

Referenced by buildBins(), clear(), distribute(), evolve(), getExpectationMap(), operator bool(), operator=(), reattachSensors(), setExpectationMap(), step(), and triggerTest().

float Searcher::m_EvolveT

protected

Definition at line 81 of file Searcher.h.

Referenced by clear(), operator=(), and Searcher().

PropVec Searcher::m_MaxModel

protected

Definition at line 67 of file Searcher.h.

Referenced by buildBins(), and cleanFlags().

PropVec Searcher::m_MinModel

protected

Definition at line 67 of file Searcher.h.

Referenced by buildBins(), and cleanFlags().

dword Searcher::m_Mode

protected

Definition at line 80 of file Searcher.h.

Referenced by evolve(), operator=(), searchDone(), startSearch(), step(), and triggerTest().

float Searcher::m_MutateRate

protected

Definition at line 82 of file Searcher.h.

Referenced by evolve(), operator=(), SearcherParams::read(), Searcher(), SearcherParams::SearcherParams(), and SearcherParams::write().

int Searcher::m_NClusters

protected

Definition at line 75 of file Searcher.h.

Referenced by buildClusters(), SearcherParams::read(), SearcherParams::SearcherParams(), and SearcherParams::write().

dword Searcher::m_NextWinID

protected

Definition at line 84 of file Searcher.h.

Referenced by evolve(), and operator=().

int Searcher::m_NPop

protected

Definition at line 70 of file Searcher.h.

Referenced by add(), clear(), evolve(), operator=(), and remove().

std::list<Model*> Searcher::m_Population

protected

Definition at line 69 of file Searcher.h.

Referenced by add(), buildBins(), buildClusters(), cleanFlags(), clear(), draw(), evolve(), getBestQOF(), getLeastQOF(), getQualityRange(), getWinners(), operator=(), reattachSensors(), remove(), step(), triggerTest(), and updateWinList().

Point Searcher::m_PosMax

protected

Definition at line 78 of file Searcher.h.

Referenced by operator=(), and setExpectationMap().

Point Searcher::m_PosMin

protected

Definition at line 78 of file Searcher.h.

Referenced by operator=(), and setExpectationMap().

Point Searcher::m_PosRange

protected

Definition at line 78 of file Searcher.h.

Referenced by buildBins(), operator=(), and setExpectationMap().

Model Searcher::m_Representative

protected

Definition at line 65 of file Searcher.h.

Referenced by buildBins(), buildClusters(), cleanFlags(), clear(), distribute(), draw(), evolve(), getRepresentative(), operator=(), reattachSensors(), and triggerTest().

float Searcher::m_ShapeWeight

protected

Definition at line 85 of file Searcher.h.

Referenced by buildBins(), getShapeWeight(), operator=(), SearcherParams::read(), Searcher(), SearcherParams::SearcherParams(), setShapeWeight(), and SearcherParams::write().

PropVec Searcher::m_StdWinner

protected

Definition at line 66 of file Searcher.h.

Referenced by buildBins(), cleanFlags(), distribute(), and operator=().

float Searcher::m_Time

protected

Definition at line 77 of file Searcher.h.

Referenced by add(), cleanFlags(), clear(), evolve(), getGeneration(), operator=(), selectWinners(), step(), and triggerTest().

std::map<dword,Winner> Searcher::m_Winners

protected

Definition at line 83 of file Searcher.h.

Referenced by clear(), draw(), evolve(), getWinList(), getWinner(), operator=(), and updateWinList().

enum { ... } Searcher::SMode

---

The documentation for this class was generated from the following files:

• src/Searcher.h
• src/Searcher.cpp