test_problems.h

#ifndef SOT_TEST_PROBLEMS_H
#define SOT_TEST_PROBLEMS_H

#include <cmath>
#include "common.h"
#include "problem.h"

namespace sot {    
    

    class Sphere : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0; 
        std::string mName = "Sphere"; 
    public:

        Sphere(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return arma::sum(x % x);
        }
    };
    

    class SumSquares : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0; 
        std::string mName = "Sum of Squares"; 
    public:

        SumSquares(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return arma::dot(arma::linspace(1, mDim, mDim), arma::square(x));
        }
    };
    

    class Schwefel22 : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0; 
        std::string mName = "Schwefel22"; 
    public:

        Schwefel22(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return arma::sum(arma::abs(x)) + arma::prod(arma::abs(x));
        }
    };
    

    class Exponential : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = -1.0; 
        std::string mName = "Exponential"; 
    public:

        Exponential(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -1.0 * arma::ones<vec>(dim);
            mxUp = 1.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return - exp(-0.5 * arma::sum(x % x));
        }
    };
    

    class Tablet : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Tablet"; 
    public:

        Tablet(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return 1e6 * (x(0) * x(0)) + arma::sum(arma::square(x.rows(1, mDim-1)));
        }
    };
    

    class Step : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Step"; 
    public:

        Step(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return arma::sum(arma::square(arma::floor(x + 0.5)));
        }
    };
    

    class Zakharov : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Zakharov"; 
    public:

        Zakharov(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -5.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            double term1 = arma::sum(arma::square(x));
            double term2 = arma::sum(0.5 * arma::dot(arma::linspace(1, mDim, mDim), x));
            return term1 + std::pow(term2, 2) + std::pow(term2, 4);
        }
    };
    

    class Rosenbrock : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Rosenbrock"; 
    public:

        Rosenbrock(int dim) {
            mDim = dim;
            mOptimum = arma::ones<vec>(dim);
            mxLow = -2.0 * arma::ones<vec>(dim);
            mxUp = 2.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            double total = 0.0;
            for(int i=0; i < mDim-1; i++) {
                total += 100.0 * std::pow(x(i)*x(i) - x(i+1), 2)  + std::pow(x(i) - 1, 2);
            }
            return total;
        }
    };
    

    class Griewank : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Griewank"; 
    public:

        Griewank(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return 1.0 + (1.0/4000) * arma::sum(x % x) - 
                    arma::prod(arma::cos(x / sqrt(arma::linspace(1, mDim, mDim))));
        }
    };
    

    class Schaffer2 : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Schaffer 2"; 
    public:

        Schaffer2(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            double total = 0.0;
            for(int i=0; i < mDim - 1; i++) {
                total += std::pow(x(i)*x(i) + x(i+1)*x(i+1), 0.25) * 
                        (std::pow(std::sin(50*std::pow(x(i)*x(i) + x(i+1)*x(i+1), 0.1)), 2.0) + 1);
            }
            return total;
        }
    };


    class Schwefel26 : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName = "Schwefel26"; 
    public:

        Schwefel26(int dim) {
            mDim = dim;
            mOptimum = 420.968746 * arma::ones<vec>(dim);
            mxLow = -500.0 * arma::ones<vec>(dim);
            mxUp = 500.0 * arma::ones<vec>(dim);
            mMinimum = - 418.9829 * dim;
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return - arma::dot(x, arma::sin(arma::sqrt(arma::abs(x))));
        }
    };
    

    class Himmelblau : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = -78.3323; 
        std::string mName = "Himmelblau"; 
    public:

        Himmelblau(int dim) {
            mDim = dim;
            mOptimum = -2.9035 * arma::ones<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return (1.0/mDim) * arma::sum( arma::pow(x, 4) - 16*arma::square(x) + 5*x);
        }
    };
    

    class Ackley : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = - 20 - exp(1); 
        std::string mName = "Ackley"; 
    public:

        Ackley(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -15.0 * arma::ones<vec>(dim);
            mxUp = 20.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return -20.0 * exp(-0.2 * sqrt(arma::sum(arma::square(x))/double(mDim))) - 
                    exp(arma::sum(arma::cos(2.0 * arma::datum::pi * x))/double(mDim));
        }
    };
    

    class Rastrigin : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName = "Rastrigin"; 
    public:

        Rastrigin(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -4.0 * arma::ones<vec>(dim);
            mxUp = 5.0 * arma::ones<vec>(dim);
            mMinimum = -dim;
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return arma::sum(arma::square(x) - arma::cos(2 * arma::datum::pi * x));
        }
    };
    

    class Michalewicz : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName = "Michalewicz"; 
    public:

        Michalewicz(int dim) {
            mDim = dim;
            mxLow = arma::zeros<vec>(dim);
            mxUp = arma::datum::pi * arma::ones<vec>(dim);
            mMinimum = -0.966 * dim;
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return - arma::sum(arma::sin(x) % arma::pow(arma::sin(
                    ((arma::linspace(1, mDim, mDim) % arma::square(x))/arma::datum::pi)), 20));
        }
    };
    

    class Keane : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName = "Keane"; 
    public:

        Keane(int dim) {
            mDim = dim;
            mxLow = arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
            mMinimum = -0.47;
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            double y1 = arma::sum((vec)arma::pow(arma::cos(x), 4.0));
            double y2 = arma::prod((vec)arma::pow(arma::cos(x), 2.0));
            double y3 = arma::sum(arma::linspace(1, mDim, mDim) % arma::square(x));
            return -fabs((y1 - 2.0 * y2) / sqrt(y3));
        }
    };
    

    class Levy : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Levy"; 
    public:

        Levy(int dim) {
            mDim = dim;
            mOptimum = arma::ones<vec>(dim);
            mxLow = -5.0 * arma::ones<vec>(dim);
            mxUp = 5.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            vec w = 1 + (x - 1)/4.0;
            double term1 = std::pow(std::sin(arma::datum::pi*w(0)), 2);
            double term3 = std::pow(w(mDim-1)-1, 2) * (1 + std::pow(std::sin(2*arma::datum::pi*w(mDim-1)), 2));
            vec wMid = w.rows(1, mDim-2);
            double term2 = arma::sum(arma::square(wMid-1) % 
                (1 + 10*arma::square(arma::sin(arma::datum::pi*wMid+1))));
            return  term1 + term2 + term3;
        }
    };
    

    class Salomon : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Salomon"; 
    public:

        Salomon(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return 1 - cos(2*arma::datum::pi*sqrt(arma::sum(arma::square(x)))) + 
                    0.1*sqrt(arma::sum(arma::square(x)));
        }
    };
    

    class Schubert3 : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = -24.062499; 
        std::string mName = "Schubert3"; 
    public:

        Schubert3(int dim) {
            mDim = dim;
            mxLow = -10.0 * arma::ones<vec>(dim);
            mxUp = 10.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const { return mxLow; }
        vec uBounds() const { return mxUp; }
        int dim() const { return mDim; }
        double min() const { return mMinimum; }
        vec optimum() const { return mOptimum; }
        std::string name() const { return mName; }
        double eval(const vec &x) const {
            double total = 0.0;
            for(int i=0; i < mDim; i++) {
                for(int j=1; j < 6; j++) {
                    total += j*sin((j+1)*x(i)) + j;
                }
            }
            return total;
        }
    };
    

    class SineEnvelope : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName = "Sine Envelope"; 
    public:

        SineEnvelope(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -20.0 * arma::ones<vec>(dim);
            mxUp = 20.0 * arma::ones<vec>(dim);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            double total = 0.0;
            for(int i=0; i < mDim-1; i++) {
                total += (std::pow(std::sin(std::sqrt(x(i)*x(i) + x(i+1)*x(i+1))), 2.0)  - 0.5)/
                        (std::pow(0.001*(x(i)*x(i) + x(i+1)*x(i+1))+1, 2.0)) + 0.5;
            }
            return total;
        }
    };
    

    class Schoen : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum = 0.0; 
        std::string mName; 
        int mk; 
        vec mf; 
        vec mAlpha; 
        mat mZ; 
        double mDistTol = 1e-10; 
    public:

        Schoen(int dim) : Schoen(dim, fmax(2^dim, 500)) {}

        Schoen(int dim, int k) {
            mName = "Schoen, k = " + std::to_string(k);
            mDim = dim;
            mk = k;
            mxLow = arma::zeros<vec>(dim);
            mxUp = arma::ones<vec>(dim);
            mf = 100 * arma::randu<vec>(k);
            mf(0) = 0;
            mAlpha = 2 + arma::randu<vec>(k);
            mZ = arma::randu<mat>(dim, k);
            mOptimum = this->mZ.col(0);
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            vec dists = squaredPointSetDistance<mat,vec>(x, mZ);
            if (arma::min(dists) < mDistTol) { // Just return the closest point
                arma::uword closest;
                double scores = dists.min(closest);
                return mf(closest);
            }
            else { 
                long double num = 0, den = 0, prodval = 0;
                for(int i=0; i < mk; i++) {
                    prodval = std::pow(std::sqrt(arma::sum(arma::square(mZ.col(i) - x))), mAlpha(i));
                    num += mf(i) / prodval;
                    den += 1 / prodval;
                }
                return num/den;
            }
        }
    };
    

    class CosineMixture : public TestProblem {
    protected:
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName = "Cosine Mixture"; 
    public:

        CosineMixture(int dim) {
            mDim = dim;
            mOptimum = arma::zeros<vec>(dim);
            mxLow = -1.0 * arma::ones<vec>(dim);
            mxUp = 1.0 * arma::ones<vec>(dim);
            mMinimum = -0.1 * dim;
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            return -0.1*arma::sum(arma::cos(5*arma::datum::pi*x)) + arma::sum(arma::square(x));
        }
    };
    

    template<class OptProb> 
    class RotatedProblem : public TestProblem {
    protected:
        std::shared_ptr<Problem> mProblem; 
        vec mTranslation; 
        mat mRotation; 
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName;  
        void createTranslation() {
            mTranslation = mxLow + (mxUp - mxLow) % arma::randu(mDim);
        }
        void createRotation() {
            mat Q, R;
            mat X = arma::randn<mat>(mDim, mDim);
            arma::qr(Q, R, X);
            mRotation = Q;
        }
    public:

        RotatedProblem(int dim) {
            mProblem = std::make_shared<OptProb>(dim);
            if (mProblem->optimum().n_elem != mProblem->dim()) {
                throw std::logic_error("Optimum not specified for: " + 
                        mProblem->name() + " so can't create a rotated version");
            }
            mDim = mProblem->dim();
            mxLow = mProblem->lBounds();
            mxUp = mProblem->uBounds();
            mMinimum = mProblem->min();
            createTranslation();
            createRotation();
            mOptimum = mTranslation;
            mName = "Rotated + Translated " + mProblem->name();
        }

        mat rotation() const {
            return mRotation;
        }

        vec translation() const {
            return mTranslation;
        }
        vec lBounds() const {
            return mxLow;
        }
        vec uBounds() const {
            return mxUp;
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            vec xx = mProblem->optimum() + mRotation * (x - mTranslation);
            return mProblem->eval(xx);
        }
    };


    template<class OptProb> 
    class UnitBoxProblem : public TestProblem {
    protected:
        std::shared_ptr<Problem> mProblem; 
        int mDim; 
        vec mxLow; 
        vec mxUp; 
        vec mOptimum; 
        double mMinimum; 
        std::string mName;  
    public:

        UnitBoxProblem(int dim) {
            mProblem = std::make_shared<OptProb>(dim);
            mDim = dim;
            mxLow = mProblem->lBounds();
            mxUp = mProblem->uBounds();
            mMinimum = mProblem->min();
            if(mProblem->optimum().n_elem == dim) {
                mOptimum = toUnitBox(mProblem->optimum(), mxLow, mxUp);
            }
            mName = mProblem->name() + " scaled to the unit box";
        }
        vec lBounds() const {
            return arma::zeros(mDim);
        }
        vec uBounds() const {
            return arma::ones(mDim);
        }
        int dim() const {
            return mDim;
        }
        double min() const {
            return mMinimum;
        }
        vec optimum() const {
            return mOptimum;
        }
        std::string name() const {
            return mName;
        }
        double eval(const vec &x) const {
            vec xx = fromUnitBox(x, mxLow, mxUp);
            return mProblem->eval(xx);
        }
    };
}

#endif