ell_config.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <ostream>
#include <utility>  // for pair
 
struct Options {
    size_t max_iters;  
    double tolerance;  
    bool verbose;      
 
    Options() : max_iters{2000}, tolerance{1e-20}, verbose{false} {}
 
    Options(size_t max_iters, double tol) : max_iters{max_iters}, tolerance{tol}, verbose{false} {}
};
 
enum class CutStatus {
    Success,   
    NoSoln,    
    NoEffect,  
    Unknown    
};
 
inline auto operator<<(std::ostream& os, CutStatus s) -> std::ostream& {
    switch (s) {
        case CutStatus::Success:
            return os << "✓ success";
        case CutStatus::NoSoln:
            return os << "✗ no solution";
        case CutStatus::NoEffect:
            return os << "⏭ no effect";
        case CutStatus::Unknown:
            return os << "? unknown";
    }
    return os;
}
 
struct CutResult {
    CutStatus status;  
    double rho;        
    double sigma;      
    double delta;      
};
 
struct CInfo {
    bool feasible;         
    size_t num_iters = 0;  
};
 
template <typename T> using ArrayType = typename T::ArrayType;
 
template <typename T> using CutChoice = typename T::CutChoice;
 
template <typename T> using CutConcept = std::pair<ArrayType<T>, CutChoice<T>>;
 
template <typename T> using RetQ = std::tuple<CutConcept<T>, bool, ArrayType<T>, bool>;
 
using SingleCut = double;
 
// --- C++20 Concepts (simple constraints to avoid MSVC ICE) ---
#if __cpp_concepts >= 201907L
#    include <concepts>
 
template <typename O, typename A>
concept OracleFeas = requires(O& o, const A& x) {
    { o.assess_feas(x) };
};
 
template <typename O, typename A, typename N>
concept OracleOptim = requires(O& o, const A& x, N& g) {
    { o.assess_optim(x, g) };
};
 
template <typename O, typename A, typename N>
concept OracleOptimQ = requires(O& o, const A& x, N& g, bool r) {
    { o.assess_optim_q(x, g, r) };
};
 
template <typename O, typename N>
concept OracleBS = requires(O& o, N& g) {
    { o.assess_bs(g) };
};
 
template <typename S>
concept SearchSpace = requires(S& s, const std::pair<typename S::ArrayType, double>& cut) {
    typename S::ArrayType;
    { s.xc() };
    { s.tsq() };
    { s.update_bias_cut(cut) } -> std::same_as<CutStatus>;
    { s.update_central_cut(cut) } -> std::same_as<CutStatus>;
};
 
#endif