network_oracle.hpp

Go to the documentation of this file.

// -*- coding: utf-8 -*-
#pragma once
 
#include <digraphx/neg_cycle.hpp>  // import NegCycleFinder
#include <optional>
#include <type_traits>
 
namespace {
    template <typename T>
    concept HasKeyType = requires { typename T::key_type; };
}  // namespace
 
template <typename Graph, typename Mapping, typename Fn>
    requires HasKeyType<Graph>
class NetworkOracle {
    using node_t = typename Graph::key_type;
 
  private:
    const Graph& _gra;
    Mapping& _u;  // vertex potentials
    NegCycleFinder<Graph> _S;
    Fn _h;
 
  public:
    NetworkOracle(const Graph& gra, Mapping& utx, Fn h)
        : _gra{gra}, _u{utx}, _S(gra), _h{std::move(h)} {}
 
    explicit NetworkOracle(const NetworkOracle&) = default;
 
    template <typename Num> auto update(const Num& gamma) -> void { this->_h.update(gamma); }
 
    template <typename Arr> auto assess_feas(const Arr& xval)
        -> std::optional<std::pair<Arr, double>> {
        // ponytail: deduce Edge type using NegCycleFinder helpers
        using Elem = decltype(*std::declval<const Graph&>().begin());
        using Nbrs = std::remove_cv_t<std::remove_reference_t<decltype(_get_val(
            std::declval<Elem>(), std::declval<const Graph&>()))>>;
        using NbrElem = decltype(*std::declval<const Nbrs&>().begin());
        using Edge = std::remove_cv_t<std::remove_reference_t<decltype(_get_val(
            std::declval<NbrElem>(), std::declval<const Nbrs&>()))>>;
 
        auto get_weight
            = [this, &xval](const Edge& edge) -> double { return this->_h.eval(edge, xval); };
 
        for (auto&& C : this->_S.howard(this->_u, get_weight)) {
            auto grad = [&]() -> Arr {
                if constexpr (std::is_arithmetic_v<Arr>) {
                    return Arr{};
                } else {
                    return Arr(xval.size());
                }
            }();
            auto fval = 0.0;
            for (auto&& edge : C) {
                fval -= this->_h.eval(edge, xval);
                grad -= this->_h.grad(edge, xval);
            }
            return std::pair{std::move(grad), fval};
        }
        return {};
    }
 
    template <typename Arr> auto operator()(const Arr& xvar)
        -> std::optional<std::pair<Arr, double>> {
        return this->assess_feas(xvar);
    }
};