solver.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_SOLVERS_SOLVER_H
#define LINE_SOLVERS_SOLVER_H
 
/**
 * @file
 * @ingroup line_solvers
 * @ingroup line_public
 * The solver API a user writes, spelled as its Python twin.
 *
 *     SolverMVA  s(model, "lin");
 *     AvgTable   t = s.avg_table();
 *
 * against Python's
 *
 *     s = MVA(model, method='lin')
 *     t = s.avg_table()
 *
 * NAMING. A multi-word getter drops the `get_` prefix (`avg_table`,
 * `tran_avg`, `cdf_respt`), because `line_solver/_aliasing.py` resolves exactly
 * that spelling onto Python's own `getAvgTable`/`getTranAvg`/`getCdfRespT`; a
 * SINGLE-word getter keeps it (`get_name`), because that same module
 * deliberately refuses to expand a bare lowercase word and Python has no
 * `name()`. So every name here is a name that also resolves in Python.
 *
 * IT IS A FACADE, NOT A SOLVER. Every method forwards to the runner the CLI
 * calls, so a program written against this header and `line-cli` on the same
 * model answer with the same numbers.
 *
 * THESE CLASSES ARE `double`-ONLY AND NOT TEMPLATES, deliberately. The solver
 * templates are a heavy instantiation and the multiprecision arithmetic has no
 * Python counterpart, so the bodies are compiled ONCE into `line_mp_api` and a
 * translation unit including this header pays for none of it. Reach for
 * `line::mva::solver_mva_run_analyzer` and its siblings directly when you want
 * another arithmetic.
 */
 
#include <cstddef>
#include <functional>
#include <string>
#include <vector>
 
#include "line/io/line_citations.h"
#include "line/lang/qn/network_builder.h"
#include "line/solvers/avg_table.h"
#include "line/solvers/cache_metrics.h"
#include "line/solvers/fj_metrics.h"
#include "line/solvers/solver_options.h"
#include "line/util/matrix.h"
 
namespace line {
 
/** `Network` as a user names it: the `double` model, Python's `Network`. */
typedef qn::Network<double> Network;
/** `model.init_routing_matrix()`'s type, Python's `RoutingMatrix`. */
typedef qn::RoutingMatrix<double> RoutingMatrix;
 
/** `getAvgChain()`: the station x chain matrices, `@NetworkSolver/getAvgChain.m`'s outputs. */
struct AvgChain {
    Matrix<double> QN, UN, RN, WN, AN, TN;
};
 
/**
 * One CTMC state as a state-set predicate sees it, the reference's `RewardState`:
 * the AGGREGATE row of `state_space_aggr()`, per-(station, class) job counts in
 * `(ist-1)*K + k` order. A Place is a station, so its count is its marking.
 */
class StateView {
  public:
    StateView(const std::vector<double>& row, const qn::NetworkStruct<double>& sn)
        : row_(&row), sn_(&sn) {}
    /** `s.at(node).total()`: jobs of every class at a station node; a handle converts. */
    double total(std::size_t node) const;
    /** `s.at(node, cls)`: jobs of class `cls` (1-based; a handle converts) at a station node. */
    double at(std::size_t node, std::size_t cls) const;
    /** The aggregate row itself. */
    const std::vector<double>& row() const { return *row_; }
 
  private:
    std::size_t column(std::size_t node, std::size_t cls) const;
    const std::vector<double>* row_;
    const qn::NetworkStruct<double>* sn_;
};
 
/**
 * A STATE SET named by a predicate, the reference's function-handle form,
 * e.g. `[&](const StateView& s) { return s.total(queue1) >= 5; }`. An empty
 * predicate names the empty set.
 */
typedef std::function<bool(const StateView&)> StatePredicate;
 
/** `getCdfFirstPassT(A, B, C, tset)`: the curve, the reach probabilities and the resolved sets. */
struct FirstPassage {
    std::vector<double> t;            ///< the grid: the caller's, else 1000 points to the horizon
    std::vector<double> F;            ///< F(t), DEFECTIVE under a taboo set
    std::vector<double> f;            ///< the density at t
    double reachprob = 0.0;           ///< probability of entering B (before C)
    double tabooprob = 0.0;           ///< probability of entering C before B
    std::vector<std::size_t> source;  ///< 0-based state rows of A; empty = conditional stationary
    std::vector<std::size_t> target;  ///< 0-based state rows of B
    std::vector<std::size_t> taboo;   ///< 0-based state rows of C minus B
};
 
/** `getFirstPassTMoments(A, B, nmax, C)`: `[m, mall, p]` with the resolved sets. */
struct FirstPassageMoments {
    std::vector<double> m;            ///< moments 1..nmax from A (conditional on B before C)
    Matrix<double> mall;              ///< (nstates x nmax), one row per starting state
    std::vector<double> p;            ///< (nstates) probability of entering B before C
    std::vector<std::size_t> source;  ///< 0-based state rows of A; empty = conditional stationary
    std::vector<std::size_t> target;  ///< 0-based state rows of B
    std::vector<std::size_t> taboo;   ///< 0-based state rows of C minus B
};
 
/**
 * The shared surface of every solver, Python's `NetworkSolver`.
 *
 * The solve is performed on first demand and cached, which is what
 * `hasResults`/`is_solved` reports; `reset()` discards it.
 */
class NetworkSolver {
  public:
    virtual ~NetworkSolver() {}
 
    /** `getName()`: the solver's own name, e.g. "MVA". */
    const std::string& get_name() const { return name_; }
    /** The options this solver was built with. */
    const SolverOptions& options() const { return opts_; }
    /** The model this solver was built on. */
    Network& model() const { return *model_; }
 
    /** `getAvgTable()`: the average table, solving on first demand. */
    const AvgTable& avg_table();
    /** `getAvgSysTable()`: per-chain system response time and throughput of the same solve. */
    AvgSysTable avg_sys_table();
    /** `getAvgQLenTable()`: `avg_table()`'s Station, JobClass and QLen columns. */
    AvgMetricTable avg_qlen_table() { return avg_metric_view(avg_table(), "QLen"); }
    /** `getAvgUtilTable()`: `avg_table()`'s Station, JobClass and Util columns. */
    AvgMetricTable avg_util_table() { return avg_metric_view(avg_table(), "Util"); }
    /** `getAvgRespTTable()`: `avg_table()`'s Station, JobClass and RespT columns. */
    AvgMetricTable avg_respt_table() { return avg_metric_view(avg_table(), "RespT"); }
    /** `getAvgTputTable()`: `avg_table()`'s Station, JobClass and Tput columns. */
    AvgMetricTable avg_tput_table() { return avg_metric_view(avg_table(), "Tput"); }
 
    /** `getAvgSysRespT()`: the per-chain system response time column of `avg_sys_table`. */
    std::vector<double> avg_sys_respt() { return avg_sys_table().SysRespT; }
    /** `getAvgSysTput()`: the per-chain system throughput column of `avg_sys_table`. */
    std::vector<double> avg_sys_tput() { return avg_sys_table().SysTput; }
 
    /** `getAvgChain()`: the station table of the same solve aggregated by chain, (nstations x nchains). */
    AvgChain avg_chain();
    /** `getAvgQLenChain()` and its siblings: one matrix of `avg_chain()` each. */
    Matrix<double> avg_qlen_chain() { return avg_chain().QN; }
    Matrix<double> avg_util_chain() { return avg_chain().UN; }
    Matrix<double> avg_respt_chain() { return avg_chain().RN; }
    Matrix<double> avg_residt_chain() { return avg_chain().WN; }
    Matrix<double> avg_arvr_chain() { return avg_chain().AN; }
    Matrix<double> avg_tput_chain() { return avg_chain().TN; }
    /** `getAvgChainTable()`: `avg_chain()` as a labelled table, one row per (station, chain). */
    AvgChainTable avg_chain_table();
    /** `runAnalyzer()`: force the solve, returning the table it produced. */
    const AvgTable& run_analyzer() { return avg_table(); }
    /** `listValidMethods()`: the methods this solver advertises on this model. */
    std::vector<std::string> list_valid_methods() const;
    /** `isSolved()` / `hasResults()`: whether a solve has been performed. */
    bool is_solved() const { return solved_; }
    /** `reset()`: discard the cached solve. */
    void reset() {
        solved_ = false;
        table_ = AvgTable();
        cache_ = solvers::CacheMetrics<double>();
        fj_ = solvers::FjMetrics<double>();
    }
    /** `getMethodUsed()`: the method the solve actually resolved to. */
    std::string method_used();
 
    /**
     * What the same solve observed at each Cache node, the data behind `getAvgCacheTable()` and
     * `getAvgItemTable()`. A Cache is not a station, so none of this reaches `avg_table()`.
     * Empty on a model without a Cache; a field the engine did not compute is an empty vector.
     */
    const solvers::CacheMetrics<double>& cache_metrics();
    /**
     * `cache.getHitRatio()` after the solve: the per-class hit probability at the named Cache,
     * NaN for a class that does not read it. Throws when the solver measured none there.
     */
    std::vector<double> hit_ratio(const std::string& cache);
    std::vector<double> hit_ratio(const Node& cache);
    /** `cache.getMissRatio()` after the solve, with `hit_ratio`'s conventions. */
    std::vector<double> miss_ratio(const std::string& cache);
    std::vector<double> miss_ratio(const Node& cache);
 
    /**
     * `getAvgFJ()`: the fork-join section metrics of the same solve, one row per Fork/Join pair
     * (`fj_sorted_pairs`), one column per class. Empty without a pair, or when the solver computes none.
     */
    const solvers::FjMetrics<double>& avg_fj();
    /** `getAvgFJTable()` (aliases `getAvgFJT`, `fjAvgT`, `aFJT`): the same metrics as a labelled table. */
    AvgFJTable avg_fj_table();
    AvgFJTable avg_fjt() { return avg_fj_table(); }
    AvgFJTable fj_avg_t() { return avg_fj_table(); }
 
  protected:
    NetworkSolver(Network& m, const std::string& name, const SolverOptions& o)
        : model_(&m), name_(name), opts_(o) {}
 
    Network* model_;
    std::string name_;
    SolverOptions opts_;
    AvgTable table_;
    solvers::CacheMetrics<double> cache_;
    solvers::FjMetrics<double> fj_;
    bool solved_ = false;
};
 
/**
 * Every solver takes the model and either a method name or a full option set,
 * mirroring Python's `SolverX(model, method_or_options=None, **kwargs)`.
 */
#define LINE_DECLARE_SOLVER(Cls, tag)                                                  \
    class Cls : public NetworkSolver {                                                 \
      public:                                                                          \
        explicit Cls(Network& m, const SolverOptions& o = SolverOptions())              \
            : NetworkSolver(m, tag, o) {}                                              \
        Cls(Network& m, const std::string& method)                                     \
            : NetworkSolver(m, tag, SolverOptions().set_method(method)) {}             \
    }
 
LINE_DECLARE_SOLVER(SolverMVA, "MVA");
LINE_DECLARE_SOLVER(SolverNC, "NC");
LINE_DECLARE_SOLVER(SolverMAM, "MAM");
LINE_DECLARE_SOLVER(SolverSSA, "SSA");
 
#undef LINE_DECLARE_SOLVER
 
/**
 * `SolverJMT`: the Java Modelling Tools client, which also answers a
 * transient, a response-time law, a state probability and a trajectory.
 *
 * IT IS NOT A BARE `LINE_DECLARE_SOLVER`, and the difference is the point: the
 * macro exposes averages alone, so a program holding a `SolverJMT` could reach
 * `getAvgTable` and nothing else while `jmt_logs.h` implemented all four of
 * these and `line-cli -s jmt` reached none of them either.
 *
 * EVERY ONE OF THEM IS READ OFF A LOGGED RUN, so each is a `jsim` answer
 * whatever `--method` asked for: JMVA computes means from a product form and
 * logs no trajectory at all.
 */
class SolverJMT : public NetworkSolver {
  public:
    explicit SolverJMT(Network& m, const SolverOptions& o = SolverOptions())
        : NetworkSolver(m, "JMT", o) {}
    SolverJMT(Network& m, const std::string& method)
        : NetworkSolver(m, "JMT", SolverOptions().set_method(method)) {}
 
    /** `getCdfRespT()`: the EMPIRICAL response-time CDF per (station, class). */
    std::vector<std::vector<CdfCurve> > cdf_respt();
 
    /**
     * `getTranAvg()`: E[N](t), averaged over `options.config.replications`
     * (`SolverOptions::replications`, default 10) independent replications
     * under method `default`; an explicit `jsim` is one run.
     *
     * A FINITE HORIZON IS REQUIRED (`options.timespan`): a transient mean over
     * an unstated horizon is not a quantity, and it is also what makes the
     * replications' event grids commensurable.
     */
    TranAvg tran_avg();
 
    /** `getProbAggr(node, state)`: the time the declared state is held for. */
    double prob_aggr(std::size_t node, const std::vector<double>& state);
 
    /**
     * `sampleSysAggr(events)`, or `sampleAggr(node, events)` when `node` is
     * given: one logged trajectory.
     *
     * `events` TRUNCATES, it does not stop the run: JMT's `maxEvents` is
     * global and cannot be asked for a count at one node, so what comes back is
     * a prefix of the run the engine produced. Zero returns all of it.
     */
    SamplePath sample(std::size_t events = 0, std::size_t node = 0);
};
 
/** `SolverCTMC`: the average table plus the chain it was computed from. */
class SolverCTMC : public NetworkSolver {
  public:
    explicit SolverCTMC(Network& m, const SolverOptions& o = SolverOptions())
        : NetworkSolver(m, "CTMC", o) {}
    SolverCTMC(Network& m, const std::string& method)
        : NetworkSolver(m, "CTMC", SolverOptions().set_method(method)) {}
 
    /** `getStateSpace()`: the aggregate state space, one row per state. */
    Matrix<double> state_space();
    /** `getGenerator()`: the infinitesimal generator over that space. */
    Matrix<double> generator();
    /** `getProbAggr(node, state)`: the aggregate marginal of one state. */
    double prob_aggr(std::size_t node, const std::vector<double>& state);
    /** `getProbStateAggr(node)`: the marginal over every state of one station. */
    std::vector<double> marg_aggr(std::size_t node);
    /** `getCdfRespT()`: the response-time CDF per (station, class). */
    std::vector<std::vector<CdfCurve> > cdf_respt();
    /**
     * `getStateSpaceAggr()`: per-(station, class) job counts of every state, in
     * `(ist-1)*K + k` column order, one row per state of `generator()`.
     */
    Matrix<double> state_space_aggr();
 
    /**
     * `getCdfFirstPassT(A, B, C, tset)`: the FIRST PASSAGE TIME from the state
     * set A into the state set B. A set is given as 1-based ROW INDICES into
     * `state_space()` or as state rows of it; an empty A starts from the
     * conditional stationary law on the complement of B.
     *
     * C is an optional TABOO set: a passage that enters C before B is lost, so
     * F becomes the DEFECTIVE law Pr{B entered by t, C not before}, tending to
     * `reachprob`. `tset` replaces the default horizon grid; an infinite entry
     * returns `reachprob`.
     */
    FirstPassage cdf_first_passt(const Matrix<double>& A, const Matrix<double>& B,
                                 const Matrix<double>& C = Matrix<double>(),
                                 const std::vector<double>& tset = std::vector<double>());
    /** As above, with the sets named by predicates over the aggregate state. */
    FirstPassage cdf_first_passt(const StatePredicate& A, const StatePredicate& B,
                                 const StatePredicate& C = StatePredicate(),
                                 const std::vector<double>& tset = std::vector<double>());
 
    /**
     * `getFirstPassTMoments(A, B, nmax, C)`: moments of order 1..nmax of the same
     * passage, exact by one linear solve per order. With a taboo set C they are
     * CONDITIONAL on entering B before C, and `mall` is NaN where B cannot be
     * entered first; `p` is the per-state probability of entering B before C.
     */
    FirstPassageMoments first_passt_moments(const Matrix<double>& A, const Matrix<double>& B,
                                            std::size_t nmax = 3,
                                            const Matrix<double>& C = Matrix<double>());
    /** As above, with the sets named by predicates over the aggregate state. */
    FirstPassageMoments first_passt_moments(const StatePredicate& A, const StatePredicate& B,
                                            std::size_t nmax = 3,
                                            const StatePredicate& C = StatePredicate());
 
    /**
     * `getSymbolicSolution()`: the stationary law over the rate symbols x1..xE.
     *
     * The generator itself needs no computer algebra, being linear in the
     * symbols, but solving pi Q = 0 over the field of rational functions does,
     * and that is delegated to the backend `options.symbolic` names. Throws
     * when no backend can be resolved rather than returning a numeric answer
     * under a symbolic name.
     */
    SymbolicSolution symbolic_solution();
 
    /** `CTMC.printInfGen(Q, SS)`: the generator beside the state it belongs to. */
    static void print_inf_gen(const Matrix<double>& Q, const Matrix<double>& space);
};
 
/** `SolverLDES`: the discrete-event simulator, which also answers the empirical response-time law. */
class SolverLDES : public NetworkSolver {
  public:
    explicit SolverLDES(Network& m, const SolverOptions& o = SolverOptions())
        : NetworkSolver(m, "LDES", o) {}
    SolverLDES(Network& m, const std::string& method)
        : NetworkSolver(m, "LDES", SolverOptions().set_method(method)) {}
    /** `SolverLDES(model, initSolver)`: warm-started from `aux`'s steady state, see `init_from_solver`. */
    SolverLDES(Network& m, NetworkSolver& aux, const SolverOptions& o = SolverOptions())
        : NetworkSolver(m, "LDES", o) {
        init_from_solver(aux);
    }
 
    /** `getCdfRespT()`: the EMPIRICAL response-time CDF per (station, class), from the per-job samples. */
    std::vector<std::vector<CdfCurve> > cdf_respt();
 
    /**
     * `initFromSolver(initSolver)`: warm-start from an auxiliary solver's steady state.
     *
     * A SolverCTMC gives the mode of its exact aggregate stationary distribution, any other solver
     * its mean queue lengths rounded to a placement conserving each closed population. The
     * placement is declared as the MODEL initial state, one row per station under a prior of one,
     * which LDES starts from as every state-driven solver does, so it changes the model shared
     * with any other solver. The transient filter is then disabled (tranfilter=fixed,
     * warmupfrac=0), since the run starts near steady state.
     */
    SolverLDES& init_from_solver(NetworkSolver& aux);
 
    /**
     * `initFromJobs(jobs)`: start from a job-level initial state, one row per job
     * [station, class, remaining, elapsed, qage, sage, order, id] with 0-based indexes.
     *
     * remaining is the work still owed (-1 a fresh draw, -2 the residual given elapsed), qage and
     * sage the time already spent at the station and in the system, order the rank at the
     * station (the first ones take the servers), id an optional tag (-1 untagged). The layout is
     * the one `final_jobs` returns, so `s2.init_from_jobs(s1.final_jobs())` continues a run where
     * it stopped, residual work included. Held by the solver rather than the model, since only
     * LDES can honour it; takes precedence over the model state and `init_sol`, and enables
     * `track_jobs`. Supported at FCFS queues, the PS family and Delays.
     */
    SolverLDES& init_from_jobs(const Matrix<double>& jobs);
 
    /**
     * `getFinalJobs()`: the jobs present at the end of the run, in the `init_from_jobs` layout.
     * A run made with `track_jobs` is reused; otherwise one is made with it. A transient run
     * (`timespan_end`) is read at its horizon.
     */
    const Matrix<double>& final_jobs();
    /** The [id, station, class, time] of every departure of a tagged job, from the same run. */
    const Matrix<double>& job_departures();
 
  private:
    void run_tracked();
    Matrix<double> final_jobs_;
    Matrix<double> job_departures_;
    bool jobs_ready_ = false;
};
 
/** `SolverFLD`: the fluid solver, which also answers a transient. */
class SolverFLD : public NetworkSolver {
  public:
    explicit SolverFLD(Network& m, const SolverOptions& o = SolverOptions())
        : NetworkSolver(m, "FLD", o) {}
    SolverFLD(Network& m, const std::string& method)
        : NetworkSolver(m, "FLD", SolverOptions().set_method(method)) {}
 
    /** `getTranAvg()`: the transient mean queue length per station. */
    TranAvg tran_avg();
    /** `getCdfRespT()`: the response-time CDF per (station, class). */
    std::vector<std::vector<CdfCurve> > cdf_respt();
};
 
/** `SolverBA`: the bounding solver, whose result is a bounds table. */
class SolverBA : public NetworkSolver {
  public:
    explicit SolverBA(Network& m, const SolverOptions& o = SolverOptions())
        : NetworkSolver(m, "BA", o) {}
    SolverBA(Network& m, const std::string& method)
        : NetworkSolver(m, "BA", SolverOptions().set_method(method)) {}
 
    /** `getBoundsTable()`: the per-class queue-length and throughput bounds. */
    BoundsTable bounds_table();
};
 
/** One row of `SolverAUTO::find_solver`: a (family, method) pair and whether this model can run it. */
struct AutoCandidate {
    std::string solver;        ///< the method family: "mva", "ctmc", "ldes", ...
    std::string method;        ///< the qualified method name to pass, "mva.exact"
    bool runnable = false;     ///< the model passes this method's own support gate
    std::string method_class;  ///< "exact", "approx", "bound" or "simulation"
    std::string metrics;       ///< the measure groups the family answers, comma-joined
    std::string reason;        ///< why a refused pair was refused, "" when runnable
};
 
/**
 * `SolverAUTO` (aliases `AUTO`, `SolverAuto`, `LINE`): the solver that picks a solver, a port of
 * `matlab/src/solvers/AUTO/@SolverAUTO` on a flat Network.
 *
 * The METHOD is a selection intent (default/auto, heur, exact, sim, fast, accurate, bound), a family
 * ('nc', 'nc.comom'), or a bare method name the first declaring family resolves ('comom' is
 * 'nc.comom'). An intent picks a ranking (`chooseSolver`), keyed on the getter asked for, whose order
 * is a RETRY LIST (`delegate.m`): the chosen solver, then every candidate the model's feature set
 * admits. A family names its engine and bypasses the ranking.
 *
 * WHAT IS DELEGATED. The average family (`avg_table` and every getter built on it: `avg_sys_table`,
 * `avg_chain*`, `avg_fj*`, the cache ratios), the response-time CDF, the transient mean, the
 * aggregate state probability, and, through the solver the reference names for each, the CTMC
 * state space, generator and symbolic solution and the BA bounds. A getter whose ranked solvers
 * expose no such call in this facade is skipped to the next candidate, never answered by a solver
 * outside the ranking.
 *
 * The selection policy cites nothing of its own (`citations.m` passes no method name), so
 * `citations()` is empty; each delegate's references are its own solver's.
 */
class SolverAUTO : public NetworkSolver {
  public:
    explicit SolverAUTO(Network& m, const SolverOptions& o = SolverOptions());
    SolverAUTO(Network& m, const std::string& method);
 
    /**
     * `getSelectedSolverName()`: the facade name ("MVA", "FLD", ...) of the delegate that answered
     * the last request, or, before any, the one the ranking picks for the mean metrics; "" when
     * no solver is feasible.
     */
    std::string selected_solver_name();
    /** `getSelectedMethod()`: the method FAMILY of that delegate, lowercase ("mva", "fld"). */
    std::string selected_method();
    /** `getCandidateSolverNames()`: the facade names of the feasible candidates, in slot order. */
    std::vector<std::string> candidate_solver_names() const;
    /** `chooseSolver(getter)`: the facade name the configured method picks for that getter. */
    std::string choose_solver(const std::string& getter = "getAvg") const;
    /** `delegate`'s retry order for that getter, as facade names; the chosen solver comes first. */
    std::vector<std::string> proposed_solver_names(const std::string& getter = "getAvg") const;
    /** `isStochastic()`: by the delegate that ran, else whether any candidate is a simulator. */
    bool is_stochastic();
    /** `isComposite()`: false, since this facade holds a flat Network. */
    bool is_composite() const { return false; }
 
    /** `listAllMethods()`: every method name the constructor accepts, independent of the model. */
    std::vector<std::string> list_all_methods() const;
    /** `findSolver(metric, showAll)`: which (family, method) pairs answer `metric` on this model. */
    std::vector<AutoCandidate> find_solver(const std::string& metric = std::string(),
                                           bool show_all = false) const;
    /** `citations()`: the selection policy's references, none. */
    std::vector<io::Citation> citations() const { return std::vector<io::Citation>(); }
 
    /** `getCdfRespT()`, delegated through the 'getCdfRespT' ranking. */
    std::vector<std::vector<CdfCurve> > cdf_respt();
    /** `getTranAvg()`, delegated through the 'getTranAvg' ranking. */
    TranAvg tran_avg();
    /** `getProbAggr(node, state)`, delegated through the 'getProbAggr' ranking. */
    double prob_aggr(std::size_t node, const std::vector<double>& state);
 
    /** `ctmcSolver()`: the SolverCTMC the generator and state-space calls go to, with these options. */
    SolverCTMC ctmc_solver() const;
    /** `fldSolver()`: the SolverFLD the fluid-only calls go to. */
    SolverFLD fld_solver() const;
    /** `ncSolver()`: the SolverNC the normalizing-constant calls go to. */
    SolverNC nc_solver() const;
    /** `baSolver()`: the SolverBA the bound calls go to, method 'auto' unless a bound method was named. */
    SolverBA ba_solver() const;
    Matrix<double> state_space() { return ctmc_solver().state_space(); }
    Matrix<double> generator() { return ctmc_solver().generator(); }
    SymbolicSolution symbolic_solution() { return ctmc_solver().symbolic_solution(); }
    BoundsTable bounds_table() { return ba_solver().bounds_table(); }
 
    /** `selectionIntents()`. */
    static std::vector<std::string> selection_intents();
    /** `familyNames()`: the method families, in the order a bare method name is looked up. */
    static std::vector<std::string> family_names();
    /** `metricGroups()`, `metricGroupOf(name)` and `familyMetrics(family)`. */
    static std::vector<std::string> metric_groups();
    static std::string metric_group_of(const std::string& name);
    static std::vector<std::string> family_metrics(const std::string& family);
    /**
     * `getFeatureSet()`: the union of the feature sets of SolverMVA, NC, CTMC, FLD, MAM, SSA, LDES
     * and JMT, as registry names. AG is deliberately absent, as in the reference.
     */
    static std::vector<std::string> feature_set();
    /** `supports(model)`: whether the model uses only features some family declares. */
    static bool supports(Network& model);
 
  private:
    /** Facade name of the delegate that answered the last delegated request, "" before any. */
    std::string last_;
};
 
// Python's short aliases: `MVA(model)` is `SolverMVA(model)`.
typedef SolverMVA MVA;
typedef SolverNC NC;
typedef SolverCTMC CTMC;
typedef SolverSSA SSA;
typedef SolverFLD FLD;
typedef SolverFLD SolverFluid;
typedef SolverMAM MAM;
typedef SolverJMT JMT;
typedef SolverLDES LDES;
typedef SolverAUTO AUTO;
typedef SolverAUTO SolverAuto;
typedef SolverAUTO LINE;
typedef SolverBA BA;
 
}  // namespace line
 
#endif  // LINE_SOLVERS_SOLVER_H