search_space.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <map>
#include <stdexcept>
#include <string>
#include <variant>
#include <vector>
 
namespace pulsatrix {
 
enum class ParameterKind { Continuous, LogUniform, Integer, Categorical };
 
struct ParameterSpec {
    std::string name;
    ParameterKind kind;
    double lower = 0.0;
    double upper = 0.0;
    std::vector<std::string> categories;
};
 
using ConfigValue = std::variant<double, int64_t, std::string>;
 
using Configuration = std::map<std::string, ConfigValue>;
 
class SearchSpace {
public:
    void AddContinuous(std::string name, double lower, double upper) {
        ValidateNewName(name);
        if (!(lower < upper)) {
            throw std::invalid_argument("SearchSpace::AddContinuous: lower must be < upper");
        }
        parameters_.push_back(ParameterSpec{std::move(name), ParameterKind::Continuous, lower,
                                             upper, {}});
    }
 
    void AddLogUniform(std::string name, double lower, double upper) {
        ValidateNewName(name);
        if (lower <= 0.0) {
            throw std::invalid_argument("SearchSpace::AddLogUniform: lower must be > 0");
        }
        if (!(lower < upper)) {
            throw std::invalid_argument("SearchSpace::AddLogUniform: lower must be < upper");
        }
        parameters_.push_back(ParameterSpec{std::move(name), ParameterKind::LogUniform, lower,
                                             upper, {}});
    }
 
    void AddInteger(std::string name, int64_t lower, int64_t upper) {
        ValidateNewName(name);
        if (lower > upper) {
            throw std::invalid_argument("SearchSpace::AddInteger: lower must be <= upper");
        }
        parameters_.push_back(ParameterSpec{std::move(name), ParameterKind::Integer,
                                             static_cast<double>(lower),
                                             static_cast<double>(upper), {}});
    }
 
    void AddCategorical(std::string name, std::vector<std::string> categories) {
        ValidateNewName(name);
        if (categories.empty()) {
            throw std::invalid_argument("SearchSpace::AddCategorical: categories must be non-empty");
        }
        parameters_.push_back(
            ParameterSpec{std::move(name), ParameterKind::Categorical, 0.0, 0.0, std::move(categories)});
    }
 
    [[nodiscard]] const std::vector<ParameterSpec>& parameters() const { return parameters_; }
 
    [[nodiscard]] size_t size() const { return parameters_.size(); }
 
    [[nodiscard]] const ParameterSpec& Get(const std::string& name) const {
        for (const auto& p : parameters_) {
            if (p.name == name) {
                return p;
            }
        }
        throw std::out_of_range("SearchSpace::Get: no parameter named '" + name + "'");
    }
 
    [[nodiscard]] bool Contains(const std::string& name) const {
        for (const auto& p : parameters_) {
            if (p.name == name) {
                return true;
            }
        }
        return false;
    }
 
private:
    void ValidateNewName(const std::string& name) const {
        if (Contains(name)) {
            throw std::invalid_argument("SearchSpace: parameter name '" + name + "' already exists");
        }
    }
 
    std::vector<ParameterSpec> parameters_;
};
 
}  // namespace pulsatrix