eoScalarFitness.h

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

  -----------------------------------------------------------------------------
  eoScalarFitness.h

 (c) Maarten Keijzer (mkeijzer@mad.scientist.com) and GeNeura Team, 1999, 2000

    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: todos@geneura.ugr.es, http://geneura.ugr.es
 */


#ifndef eoScalarFitness_h
#define eoScalarFitness_h

#include <functional>
#include <iostream>

template <class ScalarType, class Compare >
class eoScalarFitness
{
    public :

    eoScalarFitness() : value() {}
    eoScalarFitness(const eoScalarFitness& other) : value(other.value) {}
    eoScalarFitness(const ScalarType& v) : value(v) {}

    eoScalarFitness& operator=(const eoScalarFitness& other)
    { value = other.value; return *this; }
    eoScalarFitness& operator=(const ScalarType& v)
    { value = v; return *this; }

    operator ScalarType(void) const { return value; }

    bool operator<(const eoScalarFitness& other) const
    { return Compare()(value, other.value); }

        //  needed for MSVC 8 (MSVC 2005) added by J.Eggermont 20-11-2006
    bool operator<(const ScalarType& other) const
    { return Compare()(value, other); }

    // implementation of the other operators
    bool operator>( const eoScalarFitness<ScalarType, Compare>& y ) const  { return y < *this; }
    // implementation of the other operators
    bool operator<=( const eoScalarFitness<ScalarType, Compare>& y ) const { return !(*this > y); }
    // implementation of the other operators
    bool operator>=(const eoScalarFitness<ScalarType, Compare>& y ) const { return !(*this < y); }


    private :
        ScalarType value;
};
#if defined(__CUDACC__)
typedef eoScalarFitness<float, std::less<float> >    eoMaximizingFitness;
typedef eoScalarFitness<float, std::greater<float> > eoMinimizingFitness;
#else
typedef eoScalarFitness<double, std::less<double> >    eoMaximizingFitness;
typedef eoScalarFitness<double, std::greater<double> > eoMinimizingFitness;
#endif

template <class F, class Cmp>
std::ostream& operator<<(std::ostream& os, const eoScalarFitness<F, Cmp>& f)
{
    os << (F) f;
    return os;
}

template <class F, class Cmp>
std::istream& operator>>(std::istream& is, eoScalarFitness<F, Cmp>& f)
{
    F value;
    is >> value;
    f = value;
    return is;
}

#endif