Simulators

Continuous, discrete and hybrid simulation.

In namespace simulators:

Continuous

In namespace continuous:

Problem

#include<hysj/simulators/continuous/problem.hpp>

struct variables

mathematics::symbol_id independent

std::vector<mathematics::expression_ids> dependent

struct problem

mathematics::program program

continuous::variables variables

mathematics::equation_ids equations

mathematics::logical_expression_ids constraints

struct valuation

real independent

std::vector<std::vector<real>> dependen

struct root

natural index

bool positive

Constraint Automaton

#include<hysj/simulators/continuous/constraint_automaton.hpp>

struct constraint_automaton

type state

type symbol

type symbols

type graph

mathematics::equation_ids equations

std::vector<graph> graphs

constraint_automaton make_constraint_automaton(const problem&)

constraint_automaton::state start(const constraint_automaton&, const constraint_automaton::symbols&)

constraint_automaton::state advance(const constraint_automaton&, const constraint_automaton::state&, const constraint_automaton::symbol&)

bool is_active(const constraint_automaton&, const constraint_automaton::state&)

coroutines::builtin::generator<natural> active(const constraint_automaton&, const constraint_automaton::state&);

Solution

#include<hysj/simulators/continuous.hpp>

enum class event

enumerator init

enumerator start

enumerator step

enumerator stop

enumerator root

enumerator constraint

enumerator fail

struct step

enum class mode_tag

enumerator fixed

enumerator variable

mode_tag mode

real delta

struct tolerance

using absolute_type = std::variant<real, std::vector<real>>

real relative

absolute_type absolute

struct config

continuous::tolerance tolerance

continuous::step step

std::optional<real> stop

struct state

continuous::valuation valuation

continuous::root root

std::vector<graphs::builtin::vertex_id> constraints

std::vector<natural> active_constraints

struct solution

constraint_automaton &constraints() const

continuous::state &state() const

continuous::config &config() const

std::optional<event> operator()() const

solution make_solution(problem, valuation, config)

Discrete

#include<hysj/simulators/discrete.hpp>

In namespace discrete:

Automaton

#include<hysj/simulators/discrete/automaton.hpp>

struct partial_automaton

using graph_type = graphs::builtin::bincidence_graph<location, symbol>

using location_map_type = std::unordered_map<location, graphs::builtin::vertex_id, location_hasher>

graph_type graph

location_map_type location_map

Problem

#include<hysj/simulators/discrete/problem.hpp>

using variable = natural

using variables = std::vector<natural>

using value = integer

using location = std::vector<value>

using locations = std::vector<location>

struct problem

using make_symbols_type = std::function<symbols(const location&)>

using make_target_type = std::function<location(const location&, const symbol&)>

using is_immediate_type = std::function<bool(const location&, const symbol&)>

make_symbols_type make_symbols

make_target_type make_target

is_immediate_type is_immediate

Solution

#include<hysj/simulators/discrete.hpp>

enum class event

enumerator vertex

enumerator edge

enumerator halt

enumerator stuck

struct config

struct state

partial_automaton automaton

graphs::builtin::vertex_id vertex

std::optional<natural> edge

struct solution

discrete::state &state() const

discrete::config &config() const

std::optional<event> operator()() const

solution make_solution(problem, location, config)

Hybrid

#include<hysj/simulators/hybrid.hpp>

In namespace hybrid:

struct config

discrete::config discrete

continuous::config continuous

struct valuation

discrete::config discrete

continuous::config continuous

using action = std::vector<std::pair<continuous::variable_index, mathematics::expression_id>>;

using actions = std::vector<action>

struct continuous_problem

using make_equations_type = std::function<mathematics::equation_ids(mathematics::program&, const discrete::location&)>

using make_constraint_type = std::function<mathematics::logical_expression_id(mathematics::program&, const discrete::location&, const discrete::symbol&)>

continuous::variables variables

make_equations_type make_equations

make_constraint_type make_constraint

struct problem

using make_action_type = std::function<action(mathematics::program&, const discrete::location&, const discrete::symbol&)>

mathematics::program program

discrete::problem discrete

continuous_problem continuous

make_action_type make_action

using event = std::variant<continuous::event, discrete::event>

struct solution

discrete::solution &discrete() const

continuous::solution &continuous() const

std::optional<event> operator()() const

solution make_solution(problem, location, config)