ObjectiveFunction.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================

#ifndef OBJECTIVE_FUNCTION_H
#define OBJECTIVE_FUNCTION_H

#include <Rng/GlobalRng.h>
#include <SharkDefs.h>
#include <vector>
#include <string>  
#include <Array/ArrayOp.h>
#include <Array/ArrayIo.h>
#include <LinAlg/VecMat.h>


template<class T>
class ConstraintHandler
{
public:
    ConstraintHandler() { }
    virtual ~ConstraintHandler() { }

    virtual bool isFeasible(const T& point) const { return true; }
    virtual bool closestFeasible(T& point) const { return false; }
};


class BoxConstraintHandler : public ConstraintHandler<double*>
{
public:
    BoxConstraintHandler(unsigned int dim, double lower, double upper);

    BoxConstraintHandler(unsigned int dim, double lower, double upper, unsigned int exception, double exceptionLower, double exceptionUpper);

    BoxConstraintHandler(unsigned int dim, double lower, double upper, unsigned int exception1, double exception1Lower, double exception1Upper, unsigned int exception2, double exception2Lower, double exception2Upper);

    BoxConstraintHandler(const std::vector<double>& lower, const std::vector<double>& upper);

    ~BoxConstraintHandler();


    bool isFeasible(double* const& point) const;

    bool closestFeasible(double*& point) const;

    inline unsigned int dimension() const { return m_dimension; }

    inline double lowerBound(unsigned int index) const { return m_lower[index]; }

    inline double upperBound(unsigned int index) const { return m_upper[index]; }

protected:
    unsigned int m_dimension;

    std::vector<double> m_lower;

    std::vector<double> m_upper;
};


class ObjectiveFunction {
public:
    ObjectiveFunction();

    virtual ~ObjectiveFunction();


    inline unsigned timesCalled() const { return m_timesCalled; }

    inline void resetTimesCalled() { m_timesCalled = 0; }

    inline const std::string& name() const { return m_name; }

    virtual unsigned int objectives() const = 0;

protected:
    unsigned m_timesCalled;

    std::string m_name;
};


template<class T>
class ObjectiveFunctionT : public ObjectiveFunction {
public:
    ObjectiveFunctionT(ConstraintHandler<T>* constrainthandler = NULL)
    {
        this->constrainthandler = constrainthandler;
    }

    ~ObjectiveFunctionT() { }

    bool isFeasible(const T& point) const
    {
        if (constrainthandler == NULL) return true;
        else return constrainthandler->isFeasible(point);
    }

    bool closestFeasible(T& point) const
    {
        if (constrainthandler == NULL) return false;
        else return constrainthandler->closestFeasible(point);
    }

    virtual void result(const T& point, std::vector<double>& value) = 0;

    double operator() (const T& point) {
        std::vector<double> value(1);
        result(point, value);
        return value[0];
    }

    virtual bool ProposeStartingPoint(T& point) const
    {
        return false;
    }

    inline const ConstraintHandler<T>* getConstraintHandler() const
    { return constrainthandler; }

protected:
    ConstraintHandler<T>* constrainthandler;
};


template<class T>
class ObjectiveFunctionVS : public ObjectiveFunctionT<T*> {
public:
    ObjectiveFunctionVS(unsigned d = 0, ConstraintHandler<T*>* constrainthandler = NULL)
    : ObjectiveFunctionT<T*>(constrainthandler)
    , m_dimension(d)
    { };

    ~ObjectiveFunctionVS() { };


    void init(unsigned d) {
        m_dimension = d;
    }

    inline unsigned dimension() const { return m_dimension; }

    double operator()(const Array<T>& point) {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        return (*this)(const_cast<T*>(&point(0)));
    }

    double operator()(const std::vector<T>& point) {
        SIZE_CHECK(point.size() == m_dimension);
        return (*this)(const_cast<T*>(&point[0]));
    }

    double operator() (double* const& point) {
        // it makes no sence - but re-declaring this operator
        // avoids stupid compiler errors :(
        std::vector<double> value(1);
        ((ObjectiveFunctionT<const T*>*)this)->result(point, value);
        return value[0];
    }

    void result(const Array<T>& point, std::vector<double>& value) {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        ((ObjectiveFunctionT<T*>*)this)->result((T* const&)const_cast<T*>(&point(0)), value);
    }

    void result(const std::vector<T>& point, std::vector<double>& value) {
        SIZE_CHECK(point.size() == m_dimension);
        ((ObjectiveFunctionT<T*>*)this)->result(const_cast<T*>(&point[0]), value);
    }

    bool ProposeStartingPoint(T*& point) const
    {
        if (ObjectiveFunctionT<T*>::constrainthandler == NULL) return false;
        BoxConstraintHandler* bch = dynamic_cast<BoxConstraintHandler*>(ObjectiveFunctionT<T*>::constrainthandler);
        if (bch == NULL) return false;
        int i, ic = bch->dimension();
        while (true)
        {
            for (i=0; i<ic; i++) point[i] = (T)Rng::uni(bch->lowerBound(i), bch->upperBound(i));
            if (bch->isFeasible((double*&)point)) break;
        }
        return true;
    }

    inline bool isFeasible(const Array<T>& point) const {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        return ((ObjectiveFunctionT<T*>*)this)->isFeasible((T* const&)const_cast<T*>(&point(0)));
    }

    inline bool isFeasible(const std::vector<T>& point) const {
        SIZE_CHECK(point.size() == m_dimension);
        return ((ObjectiveFunctionT<T*>*)this)->isFeasible((T* const&)const_cast<T*>(&point[0]));
    }

    inline bool closestFeasible(Array<T>& point) const {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        return ObjectiveFunctionT<T*>::ClosestFeasible(&point(0));
    }

    inline bool closestFeasible(std::vector<T>& point) const {
        SIZE_CHECK(point.size() == m_dimension);
        T* p = &point[0];
        return ObjectiveFunctionT<T*>::closestFeasible(p);
    }

    inline bool ProposeStartingPoint(Array<T>& point) const {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        T* p = &point(0);
        return ProposeStartingPoint(p);
    }

    inline bool ProposeStartingPoint(std::vector<T>& point) const {
        SIZE_CHECK(point.size() == m_dimension);
        T* p = &point[0];
        return ProposeStartingPoint(p);
    }

    virtual bool utopianFitness(std::vector<double>& value) const { return false; }

    virtual bool nadirFitness(std::vector<double>& value) const { return false; }

protected:
    unsigned m_dimension;
};


class TransformedObjectiveFunction : public ObjectiveFunctionVS<double> {
public:
    TransformedObjectiveFunction(ObjectiveFunctionVS<double>& base, unsigned d = 0);

    TransformedObjectiveFunction(ObjectiveFunctionVS<double>& base, const Array<double>& transformation);

    ~TransformedObjectiveFunction();

    void init(const Array<double>& transformation);

    void initRandomRotation(unsigned d = 0);

    inline const Matrix& Transformation() const { return m_Transformation; }

    inline void result(const Array<double>& point, std::vector<double>& value)
    {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        result((double*)&point(0), value);
    }

    inline void result(const std::vector<double>& point, std::vector<double>& value)
    {
        SIZE_CHECK(point.size() == m_dimension);
        result((double*)&point[0], value);
    }

    void result(double* const& point, std::vector<double>& value);

    bool ProposeStartingPoint(double*& point) const;

    inline void transform(Array<double>& point) const {
        SIZE_CHECK(point.ndim() == 1 || point.dim(0) == m_dimension);
        std::vector<double> tmp(m_dimension);
        transform(&point(0), tmp);
        unsigned i;
        for (i=0; i<m_dimension; i++) point(i) = tmp[i];
    }

    inline void transform(std::vector<double>& point) const {
        SIZE_CHECK(point.size() == m_dimension);
        std::vector<double> tmp(m_dimension);
        transform(&point[0], tmp);
        unsigned i;
        for (i=0; i<m_dimension; i++) point[i] = tmp[i];
    }

    inline void transform(double* point) const {
        std::vector<double> tmp(m_dimension);
        transform(point, tmp);
        unsigned i;
        for (i=0; i<m_dimension; i++) point[i] = tmp[i];
    }

    bool utopianFitness(std::vector<double>& value) const;

    bool nadirFitness(std::vector<double>& value) const;

    unsigned int objectives() const;

protected:
    void transform(const double* in, std::vector<double>& out) const;

    void transformInverse(const std::vector<double>& in, double* out) const;

    ObjectiveFunctionVS<double>& baseObjective;

    Matrix m_Transformation;
};


#endif