synthetic.hpp

Go to the documentation of this file.

#ifndef __SYNTHETIC_H_
#define __SYNTHETIC_H_

#include <cmath>
#include <cstring>
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <sys/types.h>
#include <bits/stdint-intn.h>

#include <optk/core.hpp>
#include <optk/types.hpp>
#include <optk/benchmark.hpp>

namespace syn {

enum class properties: char {
    continuous,
    discontinuous,
    differentiable,
    non_differentiable,
    separable,
    partially_separable,
    non_separable,
    scalable,
    non_scalable,
    multimodal,
    unimodal
};

class synthetic: public optk::benchmark {
    public:
        synthetic (
                const std::string &n,
                u_int dims,
                double lb,
                double ub,
                double opt);

        synthetic (const std::string &n, u_int dims, double opt);

        ~synthetic ();

        sspace::sspace_t * get_search_space() { return &m_sspace; }

        void set_properties (std::vector <properties> p) { m_properties = p; }
        std::vector <properties> get_properties() { return m_properties; }

        inst::set get_opt_param () { return opt_params; }

        double get_opt () { return m_opt; }

        void update_opt (double opt) { m_opt = opt; }

        u_int get_dims () { return m_dims; }

        void validate_param_set (inst::set x);

    protected:
        void set_opt_param (inst::set op);

        u_int m_dims;
        double m_lb, m_ub, m_opt;
        std::vector<properties> m_properties;
        inst::set opt_params;
        sspace::sspace_t m_sspace;
};

class synthetic_benchmark: public optk::benchmark_set {
    public:
        synthetic_benchmark ();

        ~synthetic_benchmark () {}

        void run (optk::optimisers *opts, optk::ctx_t *ctx) override;
};

class ackley1: public synthetic {
    public:
        ackley1 (int d);
        double evaluate(inst::set x) override;
};

class ackley2: public synthetic {
    public:
        ackley2 ();
        double evaluate(inst::set x) override;
};

class ackley3: public synthetic {
    public:
        ackley3 ();
        double evaluate(inst::set x) override;
};

class adjiman: public synthetic {
    public:
        adjiman ();
        double evaluate(inst::set x) override;
};

class alpine1: public synthetic {
    public:
        alpine1 (int dims);
        double evaluate(inst::set x) override;
};

class alpine2: public synthetic {
    public:
        alpine2 (int dims);
        double evaluate(inst::set x) override;
};

class brad: public synthetic {
    public:
        brad ();
        double evaluate(inst::set x) override;
};

class bartels_conn: public synthetic {
    public:
        bartels_conn ();
        double evaluate(inst::set x) override;
};

class beale: public synthetic {
    public:
        beale ();
        double evaluate(inst::set x) override;
};

class biggs_exp2: public synthetic {
    public:
        biggs_exp2 ();
        double evaluate(inst::set x) override;
};

class biggs_exp3: public synthetic {
    public:
        biggs_exp3 ();
        double evaluate(inst::set x) override;
};

class biggs_exp4: public synthetic {
    public:
        biggs_exp4 ();
        double evaluate(inst::set x) override;
};

class biggs_exp5: public synthetic {
    public:
        biggs_exp5 ();
        double evaluate(inst::set x) override;
};

class biggs_exp6: public synthetic {
    public:
        biggs_exp6 ();
        double evaluate (inst::set x) override;
};

class bird: public synthetic {
    public:
        bird ();
        double evaluate (inst::set x) override;
};

class bohachevsky1: public synthetic {
    public:
        bohachevsky1 ();
        double evaluate (inst::set x) override;
};

class bohachevsky2: public synthetic {
    public:
        bohachevsky2 ();
        double evaluate (inst::set x) override;
};

class bohachevsky3: public synthetic {
    public:
        bohachevsky3 ();
        double evaluate (inst::set x) override;
};

class booth: public synthetic {
    public:
        booth ();
        double evaluate (inst::set x) override;
};

class box_betts: public synthetic {
    public:
        box_betts ();
        double evaluate (inst::set x) override;
};

class branin1: public synthetic {
    public:
        branin1 ();
        double evaluate (inst::set x) override;
};

class branin2: public synthetic {
    public:
        branin2 ();
        double evaluate (inst::set x) override;
};

class brent: public synthetic {
    public:
        brent ();
        double evaluate (inst::set x) override;
};

class brown: public synthetic {
    public:
        brown (int dims);
        double evaluate (inst::set x) override;
};

class bukin2: public synthetic {
    public:
        bukin2 ();
        double evaluate (inst::set x) override;
};

class bukin4: public synthetic {
    public:
        bukin4 ();
        double evaluate (inst::set x) override;
};

class bukin6: public synthetic {
    public:
        bukin6 ();
        double evaluate (inst::set x) override;
};

class camel3: public synthetic {
    public:
        camel3 ();
        double evaluate (inst::set x) override;
};

class camel6: public synthetic {
    public:
        camel6 ();
        double evaluate (inst::set x) override;
};

// We omit the chen* functions on the basis that they are difficult to
// calculate leading to floating-point errors. When we are given control over
// the experimental design, we can constrain our optimisations to values which
// are easily represented by floating-point values; henc ethese benchmarks can
// be considered somewhat unrealistic.

class chichinadze: public synthetic {
    public:
        chichinadze ();
        double evaluate (inst::set x) override;
};

class chung_reynolds: public synthetic {
    public:
        chung_reynolds (int dims);
        double evaluate (inst::set x) override;
};

class cola: public synthetic {
    public:
        cola ();
        double evaluate (inst::set x) override;
};

class colville: public synthetic {
    public:
        colville ();
        double evaluate (inst::set x) override;
};

class corana: public synthetic {
    public:
        corana ();
        double evaluate (inst::set x) override;
};

class cosine_mixture2: public synthetic {
    public:
        cosine_mixture2 ();
        double evaluate (inst::set x) override;
};

class cosine_mixture: public synthetic {
    public:
        cosine_mixture (int dims);
        double evaluate (inst::set x) override;
};

class cross_in_tray: public synthetic {
    public:
        cross_in_tray ();
        double evaluate (inst::set x) override;
};

class csendes: public synthetic {
    public:
        csendes (int dims);
        double evaluate (inst::set x) override;
};

class cube: public synthetic {
    public:
        cube ();
        double evaluate (inst::set x) override;
};


class damavandi: public synthetic {
    public:
        damavandi ();
        double evaluate (inst::set x) override;
};

class deb1: public synthetic {
    public:
        deb1 (int dims);
        double evaluate (inst::set x) override;
};

class deb2: public synthetic {
    public:
        deb2 (int dims);
        double evaluate (inst::set x) override;
};

class deckkers_aarts: public synthetic {
    public:
        deckkers_aarts ();
        double evaluate (inst::set x) override;
};

class devillers_glasser1: public synthetic {
    public:
        devillers_glasser1 ();
        double evaluate (inst::set x) override;
};

class devillers_glasser2: public synthetic {
    public:
        devillers_glasser2 ();
        double evaluate (inst::set x) override;
};

class dixon_price: public synthetic {
    public:
        dixon_price (int dims);
        double evaluate (inst::set x) override;
};

class dolan: public synthetic {
    public:
        dolan ();
        double evaluate (inst::set x) override;
};

class deceptive: public synthetic {
    public:
        deceptive (int dims);
        double evaluate (inst::set x) override;
};

class deflected_corrugated_spring: public synthetic {
    public:
        deflected_corrugated_spring (int dims);
        double evaluate (inst::set x) override;
};

class drop_wave: public synthetic {
    public:
        drop_wave ();
        double evaluate (inst::set x) override;
};

class easom: public synthetic {
    public:
        easom ();
        double evaluate (inst::set x) override;
};

class egg_crate: public synthetic {
    public:
        egg_crate ();
        double evaluate (inst::set x) override;
};

class egg_holder: public synthetic {
    public:
        egg_holder ();
        double evaluate (inst::set x) override;
};

class el_attar_vidyasagar_dutta: public synthetic {
    public:
        el_attar_vidyasagar_dutta ();
        double evaluate (inst::set x) override;
};

class exponential: public synthetic {
    public:
        exponential (int dims);
        double evaluate (inst::set x) override;
};

class exp2: public synthetic {
    public:
        exp2 ();
        double evaluate (inst::set x) override;
};

class franke: public synthetic {
    public:
        franke ();
        double evaluate (inst::set x) override;
};

class freudenstein_roth: public synthetic {
    public:
        freudenstein_roth ();
        double evaluate (inst::set x) override;
};

class gear: public synthetic {
    public:
        gear ();
        double evaluate (inst::set x) override;
};

class giunta: public synthetic {
    public:
        giunta ();
        double evaluate (inst::set x) override;
};

class goldstein_price: public synthetic {
    public:
        goldstein_price ();
        double evaluate (inst::set x) override;
};

class griewank: public synthetic {
    public:
        griewank (int dims);
        double evaluate (inst::set x) override;
};

class gulf: public synthetic {
    public:
        gulf ();
        double evaluate (inst::set x) override;
};

class hansen: public synthetic {
    public:
        hansen ();
        double evaluate (inst::set x) override;
};

class hartman3: public synthetic {
    public:
        hartman3 ();
        double evaluate (inst::set x) override;
};

class hartman6: public synthetic {
    public:
        hartman6 ();
        double evaluate (inst::set x) override;
};

class helical_valley: public synthetic {
    public:
        helical_valley ();
        double evaluate (inst::set x) override;
};

class himmelblau: public synthetic {
    public:
        himmelblau ();
        double evaluate (inst::set x) override;
};

class holder_table: public synthetic {
    public:
        holder_table ();
        double evaluate (inst::set x) override;
};

class hosaki: public synthetic {
    public:
        hosaki ();
        double evaluate (inst::set x) override;
};

class jennrich_sampson: public synthetic {
    public:
        jennrich_sampson ();
        double evaluate (inst::set x) override;
};

class judge: public synthetic {
    public:
        judge ();
        double evaluate (inst::set x) override;
};

class langermann2: public synthetic {
    public:
        langermann2 ();
        double evaluate (inst::set x) override;
};

class langermann5: public synthetic {
    public:
        langermann5 ();
        double evaluate (inst::set x) override;
};

class lennard_jones: public synthetic {
    public:
        lennard_jones ();
        double evaluate (inst::set x) override;
};

class keane: public synthetic {
    public:
        keane ();
        double evaluate (inst::set x) override;
};

class leon: public synthetic {
    public:
        leon ();
        double evaluate (inst::set x) override;
};

class levy3: public synthetic {
    public:
        levy3 (int dims);
        double evaluate (inst::set x) override;
};

class levy5: public synthetic {
    public:
        levy5 ();
        double evaluate (inst::set x) override;
};

class levy13: public synthetic {
    public:
        levy13 ();
        double evaluate (inst::set x) override;
};

class matyas: public synthetic {
    public:
        matyas ();
        double evaluate (inst::set x) override;
};

class mccormick: public synthetic {
    public:
        mccormick ();
        double evaluate (inst::set x) override;
};

typedef struct {
    int prob;
    int coef;
} rdims;

class regression: public synthetic {
    public:
        enum class dist_type: char {
            one,        
            squared,    
            inf         
        };

        regression (
            rdims dims,
            double *e_mat,
            double *centres,
            double *coefs,
            const std::string &n,
            double fmin,
            double *minloc
            );

        virtual void kernel (double *xs, double *ret) = 0;

        double evaluate (inst::set x) override;

    protected:
        void dist_sq_1 (double *xs, double *ret);

        void dist_sq_2 (double *xs, double *ret);

        void dist_sq_inf (double *xs, double *ret);

    private:

        double *m_e_mat;
        double *m_centres;
        double *m_coefs;
        rdims m_dims;
};

class court01: public regression {
    public:
        court01 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 7, coef = 6 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -0.0859426686096;
        static constexpr double minloc[prob] =
        {0.6241, 0.7688, 0.8793, 0.2739, 0.7351, 0.8499, 0.6196};

        static constexpr double centres[coef * prob] = {
            0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
            0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6,
            0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6,
            0.4, 0.7, 0.4, 0.9, 0.4, 0.1, 0.9,
            0.9, 0.3, 0.3, 0.5, 0.2, 0.7, 0.2,
            0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4};

        static constexpr double e_mat[coef * prob] = {
                5, 5, 5, 5, 5, 5, 5,
                5, 5, 5, 5, 5, 5, 5,
                5, 5, 5, 5, 5, 5, 5,
                5, 5, 5, 5, 5, 5, 5,
                5, 5, 5, 5, 5, 5, 5,
                5, 5, 5, 5, 5, 5, 5};

        static constexpr double coefs[coef] = {1, 1, -2, 1, 1, 1};
};

class court02: public regression {
    public:
        court02 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 7, coef = 6 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -2.74162116801;
        static constexpr double minloc[prob] =
        {0.4068, 0.4432, 0.6479, 0.1978, 0.7660, 0.7553, 0.5640};

        static constexpr double centres[coef * prob] = {
            0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
            0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6,
            0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6,
            0.4, 0.7, 0.4, 0.9, 0.4, 0.1, 0.9,
            0.9, 0.3, 0.3, 0.5, 0.2, 0.7, 0.2,
            0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4};

        static constexpr double e_mat[coef * prob] = {
            5. , 5. , 5. , 5. , 5. , 5. , 5. ,
            1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5,
            1. , 1. , 1. , 1. , 1. , 1. , 1. ,
            5. , 5. , 5. , 5. , 5. , 5. , 5. ,
            5. , 5. , 5. , 5. , 5. , 5. , 5. ,
            5. , 5. , 5. , 5. , 5. , 5. , 5.};

        static constexpr double coefs[coef] = {-1, -1, -2, 1, 1, -1};
};

class court03: public regression {
    public:
        court03 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 9, coef = 9 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -3.02379637466;
        static constexpr double minloc[prob] =
        { 0.9317, 0.1891, 0.2503, 0.3646, 0.1603, 0.9829, 0.0392, 0.3263,
            0.6523 };

        static constexpr double centres[coef * prob] = {
            0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
            0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6, 0.4, 0.2,
            0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6, 0.9, 0.1,
            0.7, 0.2, 0.7, 0.7, 0.3, 0.3, 0.8, 0.6, 0.4,
            0.4, 0.6, 0.4, 0.9, 0.4, 0.1, 0.9, 0.3, 0.3,
            0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4, 0.5, 0.8,
            0.8, 0.3, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6,
            0.8, 0.3, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6,
            0.8, 0.3, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6};

        static constexpr double e_mat[coef * prob] = {
                1, 1, 1, 1, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 1,
                0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
                0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
                1, 1, 1, 1, 1, 1, 1, 1, 1};

        static constexpr double coefs[coef] = {1, -1, 1, 1, 1, 1, -1, -2, -1};
};

class court04: public regression {
    public:
        court04 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 10, coef = 9 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -4.631135472012;
        static constexpr double minloc[prob] =
        { 0.8286, 0.3562, 0.3487, 0.4623, 0.1549,
          0.7182, 0.2218, 0.3919, 0.5394, 0.441};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
                0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6, 0.4, 0.2, 0.9,
                0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6, 0.9, 0.1, 0.2,
                0.7, 0.2, 0.7, 0.7, 0.3, 0.3, 0.8, 0.6, 0.4, 0.1,
                0.4, 0.6, 0.4, 0.9, 0.4, 0.1, 0.9, 0.3, 0.3, 0.2,
                0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4, 0.5, 0.8, 0.6,
                0.8, 0.4, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6, 0.5,
                0.8, 0.4, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6, 0.5,
                0.8, 0.4, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6, 0.5};

        static constexpr double e_mat[coef * prob] = {
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5,
                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
                0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5};

        static constexpr double coefs[coef] = {1, -1, 1, -1, 1, 1, -2, -1, -1};
};

class court05: public regression {
    public:
        court05 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 12, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -11.89842508364;
        static constexpr double minloc[prob] =
        { 0.636, 0.622, 0.39, 0.622, 0.29, 0.047,
          0.97, 0.26, 0.311, 0.247, 0.794, 0.189 };

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
                0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6, 0.4, 0.2, 0.9, 0.3, 0.7,
                0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6, 0.9, 0.1, 0.2, 0.5, 0.2,
                0.7, 0.2, 0.7, 0.7, 0.3, 0.3, 0.8, 0.6, 0.4, 0.1, 0.9, 0.9,
                0.4, 0.6, 0.4, 0.5, 0.4, 0.2, 0.8, 0.3, 0.3, 0.2, 0.5, 0.1,
                0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4, 0.5, 0.8, 0.6, 0.9, 0.1,
                0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0, 0.1, 0.2,
                0.8, 0.4, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.6, 0.5, 0.3, 0.8,
                0.9, 0.5, 0.3, 0.2, 0.1, 0.9, 0.3, 0.7, 0.7, 0.7, 0.4, 0.4,
                0.2, 0.8, 0.6, 0.4, 0.6, 0.6, 0.5, 0, 0.2, 0.8, 0.2, 0.3};

        static constexpr double e_mat[coef * prob] = {
                0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,
                0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,
                0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,
                0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,
                0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,
                0.08,0.08,0.08,0.08,0.08,0.08,0.08,0.08,0.08,0.08,0.08,0.08,
                0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,
                0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,0.2 ,
                0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,
                0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 ,0.4 };


        static constexpr double coefs[coef] =
            {5, -2, 5, -5, -20, -2, 10, 2, -5, 5};
};

class court06: public regression {
    public:
        court06 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 5, coef = 7 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = 2.80720263234;
        static constexpr double minloc[prob] = {1, 1, 0.7636, 0.5268, 1};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1, 0.1,
                0.3, 0.8, 0.8, 0.6, 0.9,
                0.6, 0.1, 0.2, 0.5, 0.2,
                0.7, 0.2, 0.1, 0.8, 0.9,
                0.4, 0.6, 0.5, 0.3, 0.8,
                0.9, 0.5, 0.3, 0.2, 0.4,
                0.2, 0.8, 0.6, 0.4, 0.6};

        static constexpr double e_mat[coef * prob] = {
                0.4 , 0.4 , 0.4 , 0.4 , 0.4 ,
                0.2 , 0.2 , 0.2 , 0.2 , 0.2 ,
                0.4 , 0.4 , 0.4 , 0.4 , 0.4 ,
                0.08, 0.08, 0.08, 0.08, 0.08,
                0.2 , 0.2 , 0.2 , 0.2 , 0.2 ,
                0.4 , 0.4 , 0.4 , 0.4 , 0.4 ,
                0.4 , 0.4 , 0.4 , 0.4 , 0.4};

        static constexpr double coefs[coef] = {-3, 2, -2, 4, -1, 5, -1};
};

class court07: public regression {
    public:
        court07 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 6, coef = 7 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -0.36321372933;
        static constexpr double minloc[prob] = {0.3811, 1, 0.2312, 0, 1, 0.1403};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
                0.3, 0.8, 0.8, 0.6, 0.9, 0.4,
                0.6, 1, 0.2, 0, 1, 0.3,
                0.7, 0.2, 0.1, 0.8, 0.9, 0.2,
                0.4, 0.6, 0.5, 0.3, 0.8, 0.3,
                0.9, 0.5, 0.3, 0.2, 0.4, 0.8,
                0.2, 0.8, 0.6, 0.4, 0.6, 0.9};

        static constexpr double e_mat[coef * prob] = {
                0.7 , 0.7 , 0.7 , 0.7 , 0.7 , 0.7 ,
                0.35, 0.35, 0.35, 0.35, 0.35, 0.35,
                0.7 , 0.7 , 0.7 , 0.7 , 0.7 , 0.7 ,
                0.14, 0.14, 0.14, 0.14, 0.14, 0.14,
                0.35, 0.35, 0.35, 0.35, 0.35, 0.35,
                0.7 , 0.7 , 0.7 , 0.7 , 0.7 , 0.7 ,
                0.49, 0.49, 0.49, 0.49, 0.49, 0.49};

        static constexpr double coefs[coef] = {2, 2, -4, 1, -2, 4, -2};
};

class court08: public regression {
    public:
        court08 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 4, coef = 7 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -3.45224058874;
        static constexpr double minloc[prob] = {0.5067, 1, 0.5591, 0.0823};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1,
                0.3, 0.8, 0.9, 0.4,
                0.6, 1, 0.2, 0,
                0.7, 0.2, 0.1, 0.8,
                0.4, 0, 0.8, 1,
                0.9, 0.5, 0.3, 0.2,
                0.2, 0.8, 0.6, 0.4};

        static constexpr double e_mat[coef * prob] = {
                0.7 , 0.7 , 0.7 , 0.7 ,
                0.35, 0.35, 0.35, 0.35,
                0.7 , 2.1 , 0.7 , 2.1 ,
                0.35, 0.35, 0.35, 0.35,
                1.4 , 0.7 , 1.4 , 0.7 ,
                0.7 , 0.7 , 0.7 , 0.7 ,
                0.49, 0.49, 0.49, 0.49};

        static constexpr double coefs[coef] = {2, 1, -8, 1, -5, 3, 2};
};

class court09: public regression {
    public:
        court09 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 3, coef = 8 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -10.17146707797;
        static constexpr double minloc[prob] = {0.594, 1, 0.205};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1,
                0.3, 0.8, 0.9,
                0.6, 1, 0.2,
                0.6, 1, 0.2,
                0.7, 0.2, 0.1,
                0.4, 0, 0.8,
                0.9, 0.5, 1,
                0, 0.8, 0.6};

        static constexpr double e_mat[coef * prob] = {
                0.6 , 0.6 , 0.6 ,
                0.36, 0.36, 0.36,
                0.6 , 0.3 , 0.6 ,
                2.4 , 6.  , 2.4 ,
                0.3 , 0.3 , 0.3 ,
                0.3 , 0.6 , 0.3 ,
                0.6 , 0.6 , 0.6 ,
                0.18, 0.3 , 0.3};

        static constexpr double coefs[coef] = {4, -3, -6, -2, 1, -3, 6, 2};
};

class court10: public regression {
    public:
        court10 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 8, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -2.51939597030;
        static constexpr double minloc[prob] =
            {0.5085, 0.5433, 0.2273, 1, 0.3381, 0.0255, 1, 0.5038};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
                0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6, 0.4,
                0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6, 0.9,
                0.7, 0, 0.7, 1, 0.3, 0, 0.8, 0.6,
                0.4, 0.6, 0.4, 1, 0.4, 0.2, 1, 0.3,
                0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4, 0.5,
                0.1, 0.2, 1, 0.4, 0.5, 0.6, 0.7, 0,
                0.9, 0.4, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4,
                0, 0.5, 0.3, 0.2, 0.1, 0.9, 0.3, 0.7,
                0.2, 0.8, 0.6, 0.4, 0.6, 0.6, 0.5, 0};

        static constexpr double e_mat[coef * prob] = {
                0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8,
                0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8,
                0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8,
                0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4,
                0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8,
                2.4, 2.4, 2.4, 2.4, 2.4, 2.4, 2.4, 2.4,
                0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4,
                0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8,
                1.6, 1.6, 1.6, 1.6, 1.6, 1.6, 1.6, 1.6,
                0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8};

        static constexpr double coefs[coef] =
            {5, -2, 5, -5, -12, -2, 10, 2, -5, 5};
};

class court11: public regression {
    public:
        court11 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 8, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -0.39045528652;
        static constexpr double minloc[prob] =
            {0.4, 0.6, 0.4, 1, 0.4, 0.2, 1, 0.3};

        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
                0.3, 0.1, 0.5, 0.1, 0.8, 0.8, 0.6, 0.4,
                0.6, 0.7, 0.8, 0.3, 0.7, 0.8, 0.6, 0.9,
                0.7, 0, 0.7, 1, 0.3, 0, 0.8, 0.6,
                0.4, 0.6, 0.4, 1, 0.4, 0.2, 1, 0.3,
                0.5, 0.5, 0.2, 0.8, 0.5, 0.3, 0.4, 0.5,
                0.1, 0.2, 1, 0.4, 0.5, 0.6, 0.7, 0,
                0.9, 0.4, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4,
                0, 0.5, 0.3, 0.2, 0.1, 0.9, 0.3, 0.7,
                0.2, 0.8, 0.6, 0.4, 0.6, 0.6, 0.5, 0};

        static constexpr double e_mat[coef * prob] = {
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ,
                0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ,
                1.5 , 1.5 , 1.5 , 1.5 , 1.5 , 1.5 , 1.5 , 1.5 ,
                0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ,
                1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  ,
                0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 };

        static constexpr double coefs[coef] =
            {5, -2, 5, -5, -7, -2, 10, 2, -5, 5};
};

// skip 12 because of bessel function (imported from scipy in evalse). TODO for
// completeness, implement scipy.special.jv).

class court13: public regression {
    public:
        court13 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 3, coef = 15 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = 1.49048296359;
        static constexpr double minloc[prob] = {1,1,1};

        static constexpr double centres[coef * prob] = {
                0.9, 0.9, 0.9,
                0.9, 0.9, 1,
                0.9, 1, 0.9,
                1, 0.9, 0.9,
                1, 1, 1,
                1, 0, 0,
                0.5, 0, 0,
                0, 1, 0,
                0, 0.7, 0,
                0, 0, 0,
                0.4, 0.3, 0.6,
                0.7, 0.7, 0.7,
                0.7, 0.7, 1,
                1, 0.7, 0.7,
                0.7, 1, 0.7};

        static constexpr double e_mat[coef * prob] = {
                7.6, 7.6, 7.6,
                7.6, 7.6, 7.6,
                7.6, 7.6, 7.6,
                7.6, 7.6, 7.6,
                7.6, 7.6, 7.6,
                0.8, 0.4, 0.8,
                1.6, 0.4, 0.8,
                0.4, 0.4, 0.4,
                0.4, 0.8, 0.4,
                0.8, 0.8, 0.8,
                1.6, 1.6, 2.8,
                6.8, 6.8, 6.8,
                6.8, 6.8, 6.8,
                6.8, 6.8, 6.8,
                6.8, 6.8, 6.8};

        static constexpr double coefs[coef] =
            {4, 4, 4, 4, -12, 1, 3, -2, 5, -2, 1, -2, -2, -2, -2};
};

class court14: public regression {
    public:
        court14 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 3, coef = 1 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -5;
        static constexpr double minloc[prob] = {0.1, 0.8, 0.3};
        static constexpr double centres[coef * prob] = {0.1, 0.8, 0.3};
        static constexpr double e_mat[coef * prob] = {5, 5, 5};
        static constexpr double coefs[coef] = {-5};
};

class court15: public regression {
    public:
        court15 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 3, coef = 1 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -5;
        static constexpr double minloc[prob] = {0.1, 0.8, 0.3};
        static constexpr double centres[coef * prob] = {0.1, 0.8, 0.3};
        static constexpr double e_mat[coef * prob] = {7, 7, 7};
        static constexpr double coefs[coef] = {-5};
};

class court16: public regression {
    public:
        court16 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 4, coef = 2 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -0.84221700966;
        static constexpr double minloc[prob] = {0.1858, 0.6858, 0.1858, 0.4858};
        static constexpr double centres[coef * prob] =
            {0.3, 0.8, 0.3, 0.6, 0.4, 0.9, 0.4, 0.7};
        static constexpr double e_mat[coef * prob] = {5, 5, 5, 5, 5, 5, 5, 5};
        static constexpr double coefs[coef] = {-5, 5};
};

class court17: public regression {
    public:
        court17 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 7, coef = 3 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -0.47089199032;
        static constexpr double minloc[prob] = {
            0.3125, 0.9166, 0.3125, 0.7062, 0.0397, 0.9270, 0.5979};
        static constexpr double centres[coef * prob] = {
                0.3, 0.8, 0.3, 0.6, 0.2, 0.8, 0.5,
                0.8, 0.3, 0.8, 0.2, 0.5, 0.2, 0.8,
                0.2, 0.7, 0.2, 0.5, 0.4, 0.7, 0.3};

        static constexpr double e_mat[coef * prob] = {
            4, 4, 4, 4, 4, 4, 4,
             4, 4, 4, 4, 4, 4, 4,
             4, 4, 4, 4, 4, 4, 4};

        static constexpr double coefs[coef] = {-5, 5, 5};
};

class court18: public regression {
    public:
        court18 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 8, coef = 5 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -1.42906223657;
        static constexpr double minloc[prob] =
            {0.2677, 0.8696, 0.2677, 0.6594, 0.1322, 0.9543, 0.0577, 0.295};
        static constexpr double centres[coef * prob] = {
                0.3, 0.8, 0.3, 0.6, 0.2, 0.8, 0.2, 0.4,
                0.3, 0.8, 0.3, 0.6, 0.2, 0.8, 0.2, 0.4,
                0.3, 0.8, 0.3, 0.6, 0.2, 0.8, 0.2, 0.4,
                0.8, 0.3, 0.8, 0.2, 0.5, 0.2, 0.5, 0.7,
                0.2, 0.7, 0.2, 0.5, 0.4, 0.3, 0.8, 0.8};

        static constexpr double e_mat[coef * prob] = {
                0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
                1, 1, 1, 1, 1, 1, 1, 1,
                4, 4, 4, 4, 4, 4, 4, 4,
                4, 4, 4, 4, 4, 4, 4, 4,
                4, 4, 4, 4, 4, 4, 4, 4};

        static constexpr double coefs[coef] = {-1, 2, -5, 4, 4};
};

class court19: public regression {
    public:
        court19 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 2, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -8.67263950474;
        static constexpr double minloc[prob] = {0.4, 0.8};
        static constexpr double centres[coef * prob] = {
                0.1, 0.1,
                0.3, 0.8,
                0.6, 0.7,
                0.7, 0.1,
                0.4, 0.3,
                0.2, 0.8,
                0.1, 0.2,
                0.9, 0.4,
                0.5, 0.5,
                0, 0.8};

        static constexpr double e_mat[coef * prob] = {
                3. , 3. ,
                3. , 3. ,
                3. , 3. ,
                1.5, 1.5,
                3. , 3. ,
                9. , 9. ,
                1.5, 1.5,
                3. , 3. ,
                6. , 6. ,
                3. , 3. };

        static constexpr double coefs[coef] =
            { -5, 4,  -5,  5,  4,   2, -10,  -4,   5,   5};
};

class court20: public regression {
    public:
        court20 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 2, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -6.59763663216;
        static constexpr double minloc[prob] = {0.7, 0.1};
        static constexpr double centres[coef * prob] = {
                0.1, 0.1,
                0.3, 0.8,
                0.6, 0.7,
                0.7, 0.1,
                0.4, 0.3,
                0.2, 0.8,
                0.1, 0.2,
                0.9, 0.4,
                0.5, 0.5,
                0, 0.8};

        static constexpr double e_mat[coef * prob] = {
                50.,  50.,
                50.,  50.,
                50.,  50.,
                25.,  25.,
                50.,  50.,
               150., 150.,
                25.,  25.,
                50.,  50.,
               100., 100.,
                50.,  50.};

        static constexpr double coefs[coef] =
            {5, -4, 5, -7, -4, -2, 10, 4, -2, -5};
};

class court21: public regression {
    public:
        court21 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 4, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -7.74993665759;
        static constexpr double minloc[prob] = {0.9, 0.4, 0.9, 0.8};
        static constexpr double centres[coef * prob] = {
                0.1, 0.1, 0.1, 0.1,
                0.3, 0.8, 0.5, 0.2,
                0, 0.7, 0.4, 0.9,
                0.7, 0.1, 0.2, 0.8,
                0.4, 0.3, 0.6, 0.6,
                0.2, 0.8, 0.2, 0.6,
                0.9, 0.2, 0.3, 0.4,
                0.9, 0.4, 0.9, 0.8,
                0.5, 0.5, 0.5, 0.5,
                0, 0.8, 0, 0.2};

        static constexpr double e_mat[coef * prob] = {
                10., 10., 40., 40.,
                10., 10., 40., 40.,
                30., 30., 40., 40.,
                 5.,  5., 20., 20.,
                10., 10.,  5.,  2.,
                30., 30., 10., 10.,
                 5.,  5., 40., 20.,
                10., 10., 20., 30.,
                20., 20., 30., 40.,
                10., 10.,  5.,  5.};

        static constexpr double coefs[coef] =
            {5, -4, 5, -5, 4, -2, 10, -8, -2, -5};
};

class court22: public regression {
    public:
        court22 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 5, coef = 7 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -3.08088199150;
        static constexpr double minloc[prob] =
             {0.2723, 0.4390, 0.8277, 0.3390, 0.3695};
        static constexpr double centres[coef * prob] = {
                1, 0.3, 0.1, 0.4, 0.1,
                0.9, 0.7, 0, 0.5, 0.8,
                0.5, 0.6, 0.6, 0.5, 0.5,
                0.2, 0.2, 0.4, 0, 0.3,
                0, 0.6, 1, 0.1, 0.8,
                0.3, 0.5, 0.8, 0, 0.2,
                0.8, 1, 0.1, 0.1, 0.5};

        static constexpr double e_mat[coef * prob] = {
                 5, 30, 25,  5, 15,
                10, 30, 10,  5,  5,
                 5, 10,  5, 10,  5,
                20,  5, 20,  5,  5,
                25, 30,  5, 15, 10,
                20, 10, 15,  5, 20,
                15, 25,  5, 20, 25};

        static constexpr double coefs[coef] =
            {3, 4, -4, 2, -3, -2, 6};
};

// Skip 23 because of bessel function issue; see above (12)

class court24: public regression {
    public:
        court24 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 7, coef = 9 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -0.17296443752;
        static constexpr double minloc[prob] =
             {0.7, 0.1369, 0.6, 0.2, 0.5, 0.3, 0.2};
        static constexpr double centres[coef * prob] = {
                0, 0.4, 0, 0.3, 0.2, 0.3, 0.6,
                0.6, 0.8, 0.6, 0.7, 0.7, 0.1, 0.4,
                0.7, 0.7, 0, 0.5, 0, 0.6, 0.8,
                0.7, 0.5, 0.6, 0.2, 0.5, 0.3, 0.2,
                0.9, 0.3, 0.9, 0.8, 0.7, 1, 0,
                0.8, 0.1, 0.1, 0.2, 0.6, 0.1, 0.3,
                0.2, 0.7, 0.5, 0.5, 1, 0.7, 0.4,
                0.4, 0.1, 0.4, 0.1, 0.9, 0.2, 0.9,
                0.6, 0.9, 0.1, 0.4, 0.8, 0.7, 0.1};

        static constexpr double e_mat[coef * prob] = {
                0.2, 0.4, 0.4, 0.6, 1. , 0.4, 0.2,
                1. , 0.4, 0.6, 0.6, 0.8, 0.4, 0.8,
                1. , 0.8, 0.4, 0.2, 0.8, 0.2, 0.8,
                0.8, 0.2, 0.4, 1. , 0.2, 0.4, 1. ,
                0.4, 0.8, 0.8, 0.8, 1. , 1. , 0.6,
                0.2, 0.4, 1. , 0.4, 0.2, 0.8, 1.2,
                0.2, 1.2, 0.4, 0.2, 0.8, 1. , 1.2,
                0.2, 0.2, 1. , 0.2, 0.8, 1. , 1. ,
                0.6, 1. , 0.2, 0.6, 0.4, 1. , 0.8};

        static constexpr double coefs[coef] =
            {1, 2, 3, -4, 3, -2, -1, -2, 5};
};

class court25: public regression {
    public:
        court25 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 8, coef = 10 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -4.14042985928;
        static constexpr double minloc[prob] =
             {0.2, 0.6, 0.4, 0.8, 0.4, 0.3, 0.9, 0.8};
        static constexpr double centres[coef * prob] = {
                0.5, 0, 0.3, 0.5, 0.8, 0.3, 0.2, 1,
                0.6, 0.1, 0.6, 0.9, 0.2, 0, 0.5, 0.9,
                0.9, 0.9, 0, 1, 0.5, 1, 0.1, 0,
                0.2, 0.6, 0.4, 0.8, 0.4, 0.3, 0.9, 0.8,
                0.2, 0.8, 0.5, 0.1, 0.7, 0.2, 0.4, 0.8,
                0.2, 0.1, 0.7, 0.6, 0.2, 1, 0.6, 0.2,
                0.5, 0.8, 0.6, 0, 0.6, 0.3, 0.3, 0.2,
                0, 0, 0.2, 0.8, 0.9, 0.1, 0.1, 0.5,
                0.9, 0.9, 0.1, 0.3, 0.9, 0.8, 0.7, 0,
                0.3, 0.2, 0.9, 0.8, 0.9, 0.3, 0, 0.7};

        static constexpr double e_mat[coef * prob] = {
                25, 20, 20, 30, 20, 25, 15,  5,
                30, 30,  5, 25, 10, 25, 15, 10,
                10, 20, 25, 10, 15, 30, 25, 10,
                10,  5, 15, 10,  5,  5, 10, 20,
                20, 15, 30, 20,  5,  5, 25, 20,
                25,  5, 30,  5, 20, 30, 20, 30,
                25, 15, 15, 15,  5, 15, 20, 25,
                25, 20, 10, 25,  5, 25, 15, 25,
                30, 20, 10,  5,  5, 25, 25, 20,
                15, 15, 15, 15, 10, 25, 30,  5};

        static constexpr double coefs[coef] =
            {1, 2, 3, -5, 3, -2, -1, -2, 5, 2};
};

class court26: public regression {
    public:
        court26 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 3, coef = 11 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -1.55349754312;
        static constexpr double minloc[prob] = {0.5, 0.8, 0.3};
        static constexpr double centres[coef * prob] = {
                0.5, 0.2, 0,
                0.6, 0.2, 0.5,
                0.4, 0.6, 0.5,
                0.5, 0.7, 0.3,
                0.4, 0.4, 0.4,
                0.8, 0.5, 0.8,
                0, 0, 0.8,
                0.7, 0.7, 0.2,
                0.9, 0.3, 1,
                0.4, 0.4, 0.8,
                0.2, 0.8, 0.8};

        static constexpr double e_mat[coef * prob] = {
                1. , 1. , 1. ,
                3. , 2.5, 1.5,
                1.5, 1.5, 1.5,
                2.5, 1. , 2.5,
                2. , 3. , 1.5,
                1. , 1. , 1.5,
                1. , 2. , 0.5,
                2. , 3. , 2. ,
                0.5, 1.5, 2. ,
                1.5, 1. , 1. ,
                3. , 1. , 1.5};

        static constexpr double coefs[coef] =
            {1, 2, 3, -5, 3, -2, 1, -2, 5, 2, -2};
};

class court27: public regression {
    public:
        court27 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 3, coef = 11 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -1.76908456233;
        static constexpr double minloc[prob] = {0.6, 0.3, 0.5};
        static constexpr double centres[coef * prob] = {
                0.6, 0.3, 0.5,
                0.5, 0.2, 0,
                0.4, 0.6, 0.5,
                0.5, 0.7, 0.3,
                0.4, 0.4, 0.4,
                0.8, 0.5, 0.8,
                0, 0, 0.8,
                0.7, 0, 0.2,
                0.9, 0.3, 1,
                0.4, 0.4, 0.8,
                0.2, 0.8, 0.8};

        static constexpr double e_mat[coef * prob] = {
                2, 2, 2,
                6, 5, 3,
                3, 3, 3,
                5, 2, 5,
                4, 6, 3,
                2, 2, 3,
                2, 4, 1,
                4, 6, 4,
                1, 3, 4,
                3, 2, 2,
                6, 2, 3};

        static constexpr double coefs[coef] =
            {-10, 2, 3, 5, 3, 2, 1, 2, 5, 2, 2};
};

class court28: public regression {
    public:
        court28 ();
        void kernel (double *xs, double *ret) override;
        enum { prob = 4, coef = 11 };

    private:
        static constexpr rdims dims = { .prob = prob, .coef = coef };
        static constexpr double fmin = -7.69432628909;
        static constexpr double minloc[prob] =
           {0.4493, 0.0667, 0.9083, 0.2710};
        static constexpr double centres[coef * prob] = {
                0.6, 0.2, 0.8, 0.4,
                0.1, 0.1, 0.7, 0.9,
                1, 0.1, 0.8, 0.6,
                0, 0.3, 0.2, 1,
                0.2, 1, 0.8, 0,
                0.6, 0.9, 0.2, 0.9,
                0.1, 0.7, 0.6, 0.8,
                0.8, 0.4, 0.3, 0.2,
                0.1, 1, 0.8, 0.2,
                0.3, 0.9, 0.9, 0,
                0.8, 1, 0.6, 0.9};

        static constexpr double e_mat[coef * prob] = {
                1, 1, 1, 1,
                5, 3, 3, 3,
                4, 6, 2, 4,
                4, 1, 6, 3,
                2, 5, 3, 5,
                5, 4, 6, 1,
                6, 4, 1, 6,
                5, 1, 2, 1,
                1, 5, 4, 2,
                1, 3, 3, 2,
                4, 6, 6, 2};

        static constexpr double coefs[coef] =
            {-10, 2, 3, 5, 3, 2, 1, 2, 5, 2, 2};
};

class michalewicz02: public synthetic {
    public:
        michalewicz02 ();
        double evaluate (inst::set x) override;
};

class michalewicz06: public synthetic {
    public:
        michalewicz06 ();
        double evaluate (inst::set x) override;
};

class michalewicz12: public synthetic {
    public:
        michalewicz12 ();
        double evaluate (inst::set x) override;
};

class miele_cantrell: public synthetic {
    public:
        miele_cantrell();
        double evaluate (inst::set x) override;
};

class mishra01: public synthetic {
    public:
        mishra01(int dims);
        double evaluate (inst::set x) override;
};

class mishra02: public synthetic {
    public:
        mishra02(int dims);
        double evaluate (inst::set x) override;
};

class mishra03: public synthetic {
    public:
        mishra03();
        double evaluate (inst::set x) override;
};

class mishra04: public synthetic {
    public:
        mishra04();
        double evaluate (inst::set x) override;
};

class mishra05: public synthetic {
    public:
        mishra05();
        double evaluate (inst::set x) override;
};

class mishra06: public synthetic {
    public:
        mishra06();
        double evaluate (inst::set x) override;
};

// We exclude the mishra 07 (factorial function) for reasons of computational
// unwieldiness; it is more of a computational hassle than useful or
// challenging function to optimise over.

class mishra08: public synthetic {
    public:
        mishra08();
        double evaluate (inst::set x) override;
};

class mishra09: public synthetic {
    public:
        mishra09();
        double evaluate (inst::set x) override;
};

class mishra10: public synthetic {
    public:
        mishra10();
        double evaluate (inst::set x) override;
};

class mishra11: public synthetic {
    public:
        mishra11(int dims);
        double evaluate (inst::set x) override;
};

class manifoldmin: public synthetic {
    public:
        manifoldmin(int dims);
        double evaluate (inst::set x) override;
};

class mog01: public synthetic {
    public:
        mog01 ();
        double evaluate (inst::set x) override;
};

// pick up from f85. in jamil et al
// from l.3035 in evalset:test_funcs
// https://al-roomi.org/ for reference

} // end namespace syn

#endif // __SYNTHETIC_H_