ell_base.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <utility>
#include <valarray>
 
#include "ell_config.hpp"
#include "ell_core.hpp"
 
template <typename Arr, bool Stable> class EllBase {
  public:
    using Vec = std::valarray<double>;
    using ArrayType = Arr;
 
  protected:
    size_t _n;
    Arr _xc;
    EllCore _mgr;
    Vec _g;  // scratch buffer for the cut gradient / center displacement
 
    auto operator=(const EllBase& E) -> EllBase& = delete;
 
  public:
    EllBase(const Vec& val, Arr x)
        : _n{static_cast<std::size_t>(x.size())}, _xc{std::move(x)}, _mgr(val, _n), _g(0.0, _n) {}
 
    EllBase(const double alpha, Arr x)
        : _n{static_cast<std::size_t>(x.size())}, _xc{std::move(x)}, _mgr(alpha, _n), _g(0.0, _n) {}
 
    EllBase(EllBase&& E) noexcept = default;
 
    auto operator=(EllBase&& E) noexcept -> EllBase& = default;
 
    ~EllBase() = default;
 
    explicit EllBase(const EllBase& E) = default;
 
    auto xc() const -> Arr { return this->_xc; }
 
    void set_xc(const Arr& xc) { this->_xc = xc; }
 
    constexpr auto tsq() const -> double { return this->_mgr.tsq(); }
 
    void set_use_parallel_cut(bool value) { this->_mgr.set_use_parallel_cut(value); }
 
    template <typename T> auto update_bias_cut(const std::pair<Arr, T>& cut) -> CutStatus {
        return this->_update_core(cut, [this](Vec& grad, const T& beta) {
            if constexpr (Stable) {
                return this->_mgr.update_stable_bias_cut(grad, beta);
            } else {
                return this->_mgr.update_bias_cut(grad, beta);
            }
        });
    }
 
    template <typename T> auto update_central_cut(const std::pair<Arr, T>& cut) -> CutStatus {
        return this->_update_core(cut, [this](Vec& grad, const T& beta) {
            if constexpr (Stable) {
                return this->_mgr.update_stable_central_cut(grad, beta);
            } else {
                return this->_mgr.update_central_cut(grad, beta);
            }
        });
    }
 
    template <typename T> auto update_q(const std::pair<Arr, T>& cut) -> CutStatus {
        return this->_update_core(cut, [this](Vec& grad, const T& beta) {
            if constexpr (Stable) {
                return this->_mgr.update_stable_q(grad, beta);
            } else {
                return this->_mgr.update_q(grad, beta);
            }
        });
    }
 
  protected:
    template <typename T, typename Fn>
    auto _update_core(const std::pair<Arr, T>& cut, Fn&& cut_strategy) -> CutStatus {
        const auto& grad = cut.first;
        const auto& beta = cut.second;
        auto& g = this->_g;
        for (size_t i = 0; i != this->_n; ++i) {
            g[i] = grad[i];
        }
 
        auto result = cut_strategy(g, beta);
 
        if (result == CutStatus::Success) {
            for (size_t i = 0; i != this->_n; ++i) {
                this->_xc[i] -= g[i];
            }
        }
 
        return result;
    }
};  // } EllBase