types.hpp

Go to the documentation of this file.

#ifndef __TYPES_H_
#define __TYPES_H_

#include <cstdlib>
#include <cmath>
#include <memory>
#include <random>
#include <stdexcept>
#include <string>
#include <tuple>
#include <vector>
#include <unordered_map>

#include <sys/types.h>

// Program context ------------------------------------------------------------

namespace optk {

typedef struct {
    std::string outfile;    
    uint max_iters;         
    int threads;            
    bool error;             
} ctx_t;

} // namespace optk

// Parameter values -----------------------------------------------------------

namespace inst {

enum class inst_t : char {
    node,
    int_val,
    dbl_val,
    str_val
};

class param;
class node;

typedef node *set;

typedef std::unordered_map <std::string, param *> value_map;

class param {
    public:
        param (const std::string &k, inst_t t);

        inst_t get_type () { return type; }
        std::string get_key() { return key; }

    private:
        const std::string key;
        const inst_t type;
};

// Could have used a template class for the following three classes, however
// this was not done because it ends up bloating the syntax. Also since only
// integers, doubles and strings are allowed, explicitly defining them gives a
// bit more 'type safety'.

class int_val: public param {
    public:
        int_val (const std::string &k, int v);

        int get_val () { return val; }
        void update_val (int v) { val = v; };
        int *get_addr () { return &val; }

    private:
        int val;
};

class dbl_val: public param {
    public:
        dbl_val (const std::string &k, double v);

        double get_val () { return val; }
        void update_val (double v) { val = v; };
        double *get_addr () { return &val; }

    private:
        double val;
};

class str_val: public param {
    public:
        str_val (const std::string &k, const std::string &v);

        std::string get_val () { return val; }
        void update_val (std::string v) { val = v; };
        std::string *get_addr () { return &val; }

    private:
        std::string val;
};

class node : public param {
    public:
        node (const std::string &k);

        void add_item (param *p);

        void add_items (std::vector<param *> items);

        param *get_item(const std::string &k);

        void remove_item (const std::string &k);

        value_map *get_values ()
        { return &values; }

        int getint(const std::string &key);
        int getint(int i);
        double getdbl(const std::string &key);
        double getdbl(int i);
        std::string getstr(const std::string &key);
        std::string getstr(int i);

    private:
        value_map values;
};

template <class T>
T get (node *n, const std::string &k)
{
    inst::param *tmp = n->get_item(k);
    if (tmp != NULL)
        return static_cast<T>(tmp);
    return NULL;
}

#define GETINT(dest, src, key) \
    inst::int_val *dest = static_cast<inst::int_val *>((src)->get_item (key))

#define GETDBL(dest, src, key) \
    inst::dbl_val *dest = static_cast<inst::dbl_val *>((src)->get_item (key))

#define GETSTR(dest, src, key) \
    inst::str_val *dest = static_cast<inst::str_val *>((src)->get_item (key))

#define GETNODE(dest, src, key) \
    inst::node *dest = static_cast<inst::node *>((src)->get_item (key))

void free_node (node *n);

} // namespace inst end

// Search space types ----------------------------------------------------------

enum class pt: char {
    categorical_int,
    categorical_dbl,
    categorical_str,
    choice,
    randint,
    uniform,
    quniform,
    loguniform,
    qloguniform,
    normal,
    qnormal,
    lognormal,
    qlognormal
};

namespace sspace {

class param_t
{
    public:
        param_t (std::string n, pt t);

        virtual ~param_t () {};

        virtual pt
        get_type()
        {
            return m_type;
        }

        virtual std::string
        get_name()
        {
            return m_name;
        }

    private:
        const std::string m_name;
        const pt m_type;
};

typedef std::vector<param_t *> sspace_t;

template <typename T>
class categorical: public param_t
{
    public:
        categorical (std::string n, std::vector<int> *options):
            param_t (n, pt::categorical_int)
        {
            if (options->size() == 0)
                throw std::invalid_argument("Empty value list is invalid");
            m_options = *options;
            init_rand ();
        }

        categorical (std::string n, std::vector<double> *options):
            param_t (n, pt::categorical_dbl)
        {
            if (options->size() == 0)
                throw std::invalid_argument("Empty value list is invalid");
            m_options = *options;
            init_rand ();
        }

        categorical (std::string n, std::vector<std::string> *options):
            param_t (n, pt::categorical_str)
        {
            if (options->size() == 0)
                throw std::invalid_argument("Empty value list is invalid");
            m_options = *options;
            init_rand ();
        }

        std::vector<T> *
        values()
        {
            return &m_options;
        }

        long unsigned int
        count ()
        {
            return m_options.size();
        }

        T
        get(long unsigned int i)
        {
            if (i < 0 || i > m_options.size())
                throw "Out of range";
            return m_options[i];
        }

        T
        sample ()
        {
            return get(dist(generator));
        }

    private:

        void
        init_rand ()
        {
            generator = std::mt19937 (rd ());
            uint u = m_options.size() - 1;
            if (u < 0) u = 0;
            dist = std::uniform_int_distribution<int> (0, u);
        }

        std::vector<T> m_options;

        // used to implement random sampling
        std::random_device rd;
        std::mt19937 generator;
        std::uniform_int_distribution<int> dist;
};

class choice: public param_t
{
    public:
        choice (std::string n, sspace_t *options);

        sspace_t *options();

        long unsigned int count ();

        param_t *get (long unsigned int i);

    private:
        sspace_t *m_options;
};

class randint: public param_t
{
    public:
        randint (std::string n, int lower, int upper);

        int sample ();

        int m_lower, m_upper;

    private:
        std::random_device rd;
        std::mt19937 generator;
        std::uniform_int_distribution<int> dist;
};

class uniform: public param_t
{
    public:

        uniform (std::string n, double lower, double upper);

        uniform (std::string n, double lower, double upper, pt type);

        virtual double sample();

        double m_lower, m_upper;

    protected:
        std::random_device rd;
        std::mt19937 generator;
        std::uniform_real_distribution<double> dist;
};

class quniform: public uniform {
    public:
        quniform (std::string n, double lower, double upper, double q);

        double sample();

        double m_q;
};

class loguniform: public uniform {
    public:
        loguniform (std::string n, double lower, double upper);

        loguniform (std::string n, double lower, double upper, pt t);

        double sample ();
};

class qloguniform: public loguniform {

    public:

        qloguniform (std::string n, double lower, double upper, double q);

        double sample ();

        double m_q;
};

class normal: public param_t {
    public:
        normal (std::string n, double mu, double sigma);

        normal (std::string n, double mu, double sigma, pt t);

        virtual double sample ();

        double m_mu, m_sigma;

    protected:
        std::random_device rd;
        std::mt19937 generator;
        std::normal_distribution<double> dist;
};

class qnormal: public normal {
    public:
        qnormal (std::string n, double mu, double sigma, double q);

        double sample ();

        double m_q;
};

class lognormal: public normal {
    public:
        lognormal (std::string n, double mu, double sigma);

        lognormal (std::string n, double mu, double sigma, pt t);

        double sample ();
};

class qlognormal: public lognormal {
    public:
        qlognormal (std::string n, double mu, double sigma, double q);

        double sample ();

        double m_q;
};

void validate_param_values (inst::value_map *vals, sspace::sspace_t *sspace);

void free_ss (sspace_t *ss);

} // namespace sspace

#endif // __TYPES_H_