C:/dev/de/differentialevolution/de_constraints.hpp

/*
 * Copyright (c) 2011 Adrian Michel
 * http://www.amichel.com
 *
 * Permission to use, copy, modify, distribute and sell this 
 * software and its documentation for any purpose is hereby 
 * granted without fee, provided that both the above copyright 
 * notice and this permission notice appear in all copies and in 
 * the supporting documentation. 
 *  
 * This library is distributed in the hope that it will be 
 * useful. However, Adrian Michel makes no representations about
 * the suitability of this software for any purpose.  It is 
 * provided "as is" without any express or implied warranty. 
 * 
 * Should you find this library useful, please email 
 * info@amichel.com with a link or other reference 
 * to your work. 
*/

#ifndef DE_CONSTRAINTS_HPP_INCLUDED
#define DE_CONSTRAINTS_HPP_INCLUDED

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

#include <set>
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
#include <boost/make_shared.hpp>
#include <boost/lexical_cast.hpp>

#include "random_generator.hpp"
#include "de_types.hpp"

namespace de
{

class constraints_exception : public exception
{
public:
        constraints_exception( const std::string& message )
        : exception( message.c_str() )
        {
        }
};

class constraint
{
public:
        virtual ~constraint(){}

        virtual double get_rand_value() = 0;

        virtual double get_rand_value( double value, double origin ) = 0;

        virtual double min() const = 0;

        virtual double max() const = 0;

        virtual double get_rand_value_in_zone( double origin, double zonePct ) const = 0;

        virtual double get_middle_point() = 0;
};

typedef boost::shared_ptr< constraint > constraint_ptr;

class range_constraint : public constraint
{
private:
        double m_min;
        double m_max;

public:

        range_constraint( double min, double max )
        : m_min( min ), m_max( max )
        {
                assert( min <= max );
        }

        double min() const { return m_min; }

        double max() const { return m_max; }

};

class real_constraint : public range_constraint
{
public:

        real_constraint( double min, double max )
        : range_constraint( min, max )
        {
                assert( min <= max );
        }

        double get_rand_value()
        {
                return genrand( range_constraint::min(), range_constraint::max() );
        }

        double get_rand_value( double value, double origin )
        {
                double ret = value;

                while( ret < range_constraint::min() )
                {
                        ret = range_constraint::min() + genrand() * ( origin - range_constraint::min() );
                }

                while( ret > range_constraint::max() )
                {
                        ret = range_constraint::max() + genrand() * ( origin - range_constraint::max() );
                }

                return ret;
        }

        virtual double get_rand_value_in_zone( double origin, double zonePct ) const
        {
                if( origin > max() )
                        throw constraints_exception( "origin coordinate > max" );
                if( origin < min() )
                        throw constraints_exception( "origin coordinate < min" );

                if( zonePct > 100.0 )
                        throw constraints_exception( "zonePct > 100%" );

                if( zonePct < 0 )
                        throw constraints_exception( "zonePct < 0%" );

                if( zonePct == 0 )
                        throw constraints_exception( "zonePct == 0%" );

                double zoneSize = ( max() - min() ) * zonePct / 100.0;

                double _min = std::max( min(), origin - zoneSize/2.0 );
                double _max = std::min( max(), origin + zoneSize/2.0 );

                return genrand( _min, _max );
        }

        virtual double get_middle_point()
        {
                return ( max() + min() )/2.0;
        }

};

class int_constraint : public range_constraint
{
public:
        int_constraint( double min, double max )
        : range_constraint( min, max )
        {
                assert( min <= max );
        }

        double get_rand_value()
        {
                return genintrand( range_constraint::min(), range_constraint::max() );
        }

        double get_rand_value( double value, double origin )
        {
                double ret = boost::math::round( value );

                while( ret < range_constraint::min() )
                {
                        ret = range_constraint::min() + genrand() * ( origin - range_constraint::min() );
                        ret = boost::math::round( ret );
                }

                while( ret > range_constraint::max() )
                {
                        ret = range_constraint::max() + genrand() * ( origin - range_constraint::max() );
                        ret = boost::math::round( ret );
                }

                return ret;
        }

        virtual double get_rand_value_in_zone( double origin, double zonePct ) const
        {
                if ( origin > max() )
                        throw constraints_exception( "origin coordinate > max" );
                if ( origin < min() )
                        throw constraints_exception( "origin coordinate < min" );

                if ( zonePct > 100.0 )
                        throw constraints_exception( "zonePct > 100%" );

                if( zonePct < 0 )
                        throw constraints_exception( "zonePct < 0%" );

                if( zonePct == 0  )
                        throw constraints_exception( "zonePct == 0%" );

                double zoneSize = ( max() - min() ) * zonePct/100.0;

                double _min = std::max( min(), origin - zoneSize/2.0 );
                double _max = std::min( max(), origin + zoneSize/2.0 );

                double val = boost::math::round( genrand( _min, _max ) );

                for ( ;val < _min || val > _max; val = boost::math::round( genrand( _min, _max ) ) );

                return val;
        }

        virtual double get_middle_point()
        {
                return boost::math::round( ( max() - min() )/2.0 );
        }


};

class set_constraint : public constraint
{
private:
        class unique : public std::unary_function < Double, bool >
        {
        public:
                bool operator ()( Double d ) const  
                {
                        return m_unique.insert( d ).second;
                }

        public:
                double min() const 
                { 
                        if( m_unique.size() > 0 )
                                return *m_unique.begin(); 
                        else
                                throw constraints_exception( "could not get the min value of an empty set constraint" );
                }

                double max() const 
                { 
                        if( m_unique.size() > 0 )
                                return *m_unique.rbegin(); 
                        else
                                throw constraints_exception( "could not get the max value of an empty set constraint" );
                }

        private:
                mutable std::set< Double > m_unique;
        };
private:
        unique m_unique;
        de::DVector m_values;

public:
        set_constraint( const de::DVector& values )
        {
                // making sure the values in the "set" are unique
                std::remove_copy_if (values.begin (), values.end (), std::back_inserter( m_values ), m_unique );
        }

        void add_value( de::Double value )
        {
                if( m_unique( value ) )
                        m_values.push_back( value );
        }

        virtual double get_rand_value()
        {
                de::DVector::size_type index( genintrand( 0, m_values.size() - 1 ) );

                return m_values[ index ];
        }

        virtual double get_rand_value(double value, double origin)
        {
                return get_rand_value();
        }

        double min() const
        {
                return m_unique.min();
        }

        double max() const
        {
                return m_unique.max();
        }

        virtual double get_rand_value_in_zone( double origin, double zonePct ) const
        {
                throw constraints_exception( "get_rand_value_in_zone only supported for range constraints" );
        }

        virtual double get_middle_point()
        {
                throw constraints_exception( "get_middle_point not supported by set constraint" );
        }

};

class boolean_constraint : public constraint
{
public:
        virtual double get_rand_value()
        {
                return genrand() < 0.5;
        }

        virtual double get_rand_value(double value, double origin)
        {
                return get_rand_value();
        }

        double min() const
        {
                return 0;
        }

        double max() const
        {
                return 1;
        }

        virtual double get_rand_value_in_zone( double origin, double zonePct ) const
        {
                throw constraints_exception( "get_rand_value_in_zone only supported for range constraints" );
        }

        virtual double get_middle_point()
        {
                throw constraints_exception( "get_middle_point not supported by bool constraint" );
        }

};

typedef std::vector< constraint_ptr > constraints_base;

class constraints : public constraints_base
{
private:
        typedef boost::char_separator< char > separator;
        typedef boost::tokenizer< separator > tokenizer;
        

public:
        constraints( size_t varCount, double defMin, double defMax )
        : constraints_base( varCount, boost::make_shared< real_constraint >( defMin, defMax ) )
        {
        }

        constraints( const std::vector< std::string >& str, size_t var_count , double def_min, double def_max )
        : constraints_base( var_count, boost::make_shared< real_constraint >( def_min, def_max ) )
        {
                for( std::vector< std::string >::size_type i = 0; i < str.size(); ++i )
                {
                        tokenizer tokens( str[ i ], separator( ";," ) );

                        std::string type;
                        double _min;
                        double _max;

                        size_t count( 0 );

                        for( tokenizer::const_iterator j = tokens.begin(); j != tokens.end(); ++j, ++count )
                        {
                                const std::string token( boost::trim_copy( *j ) );

                                try
                                {
                                        switch( count )
                                        {
                                                case 0:
                                                        type = token;
                                                        break;
                                                case 1:
                                                        _min = boost::lexical_cast< double >( token.c_str() );
                                                        break;
                                                case 2:
                                                        _max = boost::lexical_cast< double >( token.c_str() );
                                                        break;
                                                default:
                                                        // too many fields
                                                        throw constraints_exception( ( boost::format( "wrong variable format in \"%1%\" - too many fields" ) % str[ i ] ).str() );

                                        }
                                }
                                catch( const boost::bad_lexical_cast& )
                                {
                                        throw constraints_exception( ( boost::format( "wrong floating point number format: %1%") % token ).str() );
                                }
                        }

                        // too few fields
                        if( count < 3 )
                                throw constraints_exception( ( boost::format( "wrong variable format in \"%1%\" - too few fields" ) % str[ i ] ).str() );

                        if( i < var_count )
                                constraints_base::at( i ) = str_to_constraint( type, _min, _max );
                        else
                                constraints_base::push_back( str_to_constraint( type, _min, _max ) );
                }
        }

        double get_rand_value( size_t index )
        {
                if( index < constraints_base::size() )
                        return (*this)[ index ]->get_rand_value();
                else
                        throw constraints_exception( ( boost::format( "invalid constraint index: %1%, higher than max number of constraints: %2%" ) % index % constraints_base::size() ).str() );
        }

        double get_rand_value( size_t index, double value, double origin )
        {
                if( index < constraints_base::size() )
                        return (*this)[ index ]->get_rand_value( value, origin );
                else
                        throw constraints_exception( ( boost::format( "invalid constraint index: %1%, higher than max number of constraints: %2%" ) % index % constraints_base::size() ).str() );
        }

        DVectorPtr get_square_zone_rand_values( const DVectorPtr origin, double sidePct ) const
        {
                assert( origin );
                assert( sidePct > 0 && sidePct <= 100 );

                if( origin->size() == constraints_base::size() )
                {
                        DVectorPtr square( boost::make_shared< DVector >( origin->size() ) );

                        for( constraints_base::size_type n = 0; n < constraints_base::size(); ++n )
                                (*square)[ n ] = (*this)[ n ]->get_rand_value_in_zone( (*origin)[ n ], sidePct );

                        return square;

                }
                else
                        throw constraints_exception( "The origin vector must have the same number of elements as there are constraints" );
        }

        DVectorPtr get_middle_point()
        {
                DVectorPtr r( boost::make_shared< DVector >( constraints_base::size() ) );

                for( constraints_base::size_type n = 0; n < constraints_base::size(); ++n )
                        (*r)[ n ] = (*this)[ n ]->get_middle_point();

                return r;

        }

        DVectorPtr get_rand_values() const
        {
                DVectorPtr r( boost::make_shared< DVector >( constraints_base::size() ) );

                for( constraints_base::size_type n = 0; n < constraints_base::size(); ++n )
                        (*r)[ n ] = (*this)[ n ]->get_rand_value();

                return r;
        }


private:
        constraint_ptr str_to_constraint( const std::string& type, double min, double max )
        {
                if( boost::to_lower_copy( type ) == "real" )
                        return boost::make_shared< real_constraint >( min, max );
                else if( boost::to_lower_copy( type ) == "int" || boost::to_lower_copy( type ) == "integer" )
                        return boost::make_shared< int_constraint >( min, max );
                else
                        throw constraints_exception( ( boost::format( "invalid constraint type \"%1%\"" ) % type ).str() );
        }
};

typedef boost::shared_ptr< constraints > constraints_ptr;

}

#endif //DE_CONSTRAINTS_HPP_INCLUDED