PO.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

//-----------------------------------------------------------------------------
// PO.h
// (c) OPAC 2007
/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Contact: thomas.legrand@lifl.fr
 */
//-----------------------------------------------------------------------------

#ifndef PO_H
#define PO_H

//-----------------------------------------------------------------------------
#include <stdexcept>
#include <EO.h>
//-----------------------------------------------------------------------------

template < class F > class PO:public EO < F >
{

public:

        #if defined(__CUDACC__)
                typedef typename EO < F >::Fitness Fitness;
        #else
                typedef typename PO<F>::Fitness Fitness;
        #endif

    PO ():repFitness (Fitness ()), invalidFitness (true),
            bestFitness (Fitness()){}


    Fitness fitness () const
    {
        if (invalid ())
            throw std::runtime_error ("invalid fitness in PO.h");
        return repFitness;
    }


    void fitness (const Fitness & _fitness)
    {
        repFitness = _fitness;
        invalidFitness = false;
    }

    Fitness best () const
    {
        if (invalid ())
            throw std::runtime_error ("invalid best fitness in PO.h");
        return bestFitness;
    }


    void best (const Fitness & _bestFitness)
    {
        bestFitness = _bestFitness;
        invalidBestFitness = false;
    }


    bool invalid () const
    {
        return invalidFitness;
    }

    void invalidate ()
    {
        invalidFitness = true;
    }

    bool invalidBest () const
    {
        return invalidBestFitness;
    }

    void invalidateBest ()
    {
        invalidBestFitness = true;
    }

    virtual std::string className () const
    {
        return "PO";
    }

    bool operator< (const PO & _po2) const { return fitness () < _po2.fitness ();}
    bool operator> (const PO & _po2) const { return !(fitness () <= _po2.fitness ());}


    virtual void printOn(std::ostream& _os) const { _os << bestFitness << ' ' ;}


    virtual void readFrom(std::istream& _is) {

        // the new version of the reafFrom function.
        // It can distinguish between valid and invalid fitness values.
        std::string fitness_str;
        int pos = _is.tellg();
        _is >> fitness_str;

        if (fitness_str == "INVALID")
        {
            invalidFitness = true;
        }
        else
        {
            invalidFitness = false;
            _is.seekg(pos); // rewind
            _is >> repFitness;
        }
    }

private:
    Fitness repFitness;         // value of fitness for this particle
    bool invalidFitness;                // true if the value of the fitness is invalid

    Fitness bestFitness;                // value of the best fitness found for the particle
    bool invalidBestFitness;    // true if the value of the best fitness is invalid

};

//-----------------------------------------------------------------------------

#endif /*PO_H */