alarsyo/spot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Fix typos in doc, comments and messages

Browse source 
* bin/README, bin/common_conv.hh, bin/common_trans.cc,
    bin/ltlsynt.cc, bin/spot-x.cc, spot/gen/automata.hh,
    spot/graph/graph.hh, spot/ltsmin/ltsmin.hh,
    spot/ltsmin/spins_interface.hh, spot/ltsmin/spins_kripke.hh,
    spot/mc/bloemen.hh, spot/mc/bloemen_ec.hh, spot/mc/cndfs.hh,
    spot/mc/deadlock.hh, spot/mc/intersect.hh, spot/mc/lpar13.hh,
    spot/mc/mc_instanciator.hh, spot/misc/bareword.cc,
    spot/misc/fixpool.hh, spot/misc/formater.hh, spot/misc/minato.hh,
    spot/misc/satsolver.hh, spot/misc/timer.hh,
    spot/parseaut/public.hh, spot/priv/partitioned_relabel.cc,
    spot/priv/satcommon.hh, spot/ta/ta.hh, spot/ta/taexplicit.cc,
    spot/ta/taproduct.hh, spot/ta/tgta.hh, spot/taalgos/reachiter.hh,
    spot/taalgos/tgba2ta.hh, spot/tl/apcollect.cc,
    spot/tl/apcollect.hh, spot/tl/formula.cc, spot/tl/parse.hh,
    spot/tl/randomltl.hh, spot/tl/relabel.hh, spot/tl/simplify.cc,
    spot/twa/acc.hh, spot/twa/bddprint.hh, spot/twa/formula2bdd.cc,
    spot/twa/twa.hh, spot/twa/twagraph.cc, spot/twa/twagraph.hh,
    spot/twaalgos/aiger.cc, spot/twaalgos/aiger.hh,
    spot/twaalgos/alternation.hh,  spot/twaalgos/cleanacc.cc,
    spot/twaalgos/cobuchi.cc, spot/twaalgos/contains.cc,
    spot/twaalgos/couvreurnew.cc, spot/twaalgos/cycles.hh,
    spot/twaalgos/degen.cc, spot/twaalgos/degen.hh,
    spot/twaalgos/dot.hh, spot/twaalgos/dtbasat.cc,
    spot/twaalgos/dtwasat.cc, spot/twaalgos/dtwasat.hh,
    spot/twaalgos/dualize.cc, spot/twaalgos/emptiness.hh,
    spot/twaalgos/emptiness_stats.hh, spot/twaalgos/game.cc,
    spot/twaalgos/genem.hh, spot/twaalgos/hoa.hh,
    spot/twaalgos/langmap.hh, spot/twaalgos/ltl2tgba_fm.hh,
    spot/twaalgos/magic.cc, spot/twaalgos/magic.hh,
    spot/twaalgos/mask.hh, spot/twaalgos/mealy_machine.cc,
    spot/twaalgos/mealy_machine.hh,
    spot/twaalgos/minimize.hh, spot/twaalgos/parity.cc,
    spot/twaalgos/parity.hh, spot/twaalgos/postproc.cc,
    spot/twaalgos/product.hh, spot/twaalgos/reachiter.hh,
    spot/twaalgos/relabel.cc, spot/twaalgos/remfin.cc,
    spot/twaalgos/remfin.hh, spot/twaalgos/sccfilter.cc,
    spot/twaalgos/sccinfo.hh, spot/twaalgos/se05.cc,
    spot/twaalgos/se05.hh, spot/twaalgos/simulation.hh,
    spot/twaalgos/split.hh, spot/twaalgos/stats.hh,
    spot/twaalgos/synthesis.cc, spot/twaalgos/synthesis.hh,
    spot/twaalgos/tau03.hh, spot/twaalgos/tau03opt.hh,
    spot/twaalgos/toparity.hh, spot/twaalgos/totgba.hh,
    spot/twaalgos/translate.hh, spot/twaalgos/word.cc,
    spot/twaalgos/word.hh, spot/twaalgos/zlktree.cc,
    spot/twaalgos/zlktree.hh, spot/twacube/cube.hh,
    spot/twacube/twacube.hh, tests/core/cube.cc,
    tests/core/ltlsynt.test, tests/core/parity.cc,
    tests/core/safra.cc, tests/core/twagraph.cc: here
This commit is contained in:
Florian Renkin 2024-04-16 16:24:54 +02:00
parent 952e502480
commit 96ff2225e3
106 changed files with 228 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

2
bin/README
View file

@ -12,7 +12,7 @@ whose purpose is just to generate a man-page with the same format as
the other man pages (this includes keeping the version number the other man pages (this includes keeping the version number
up-to-date). up-to-date).
There is also a script called 'options.py' that summerizes how the There is also a script called 'options.py' that summarizes how the
different short options are used among the tools. different short options are used among the tools.
Routines that are shared by multiple command-line tools are stored in Routines that are shared by multiple command-line tools are stored in

2
bin/common_conv.hh
View file

@ -27,5 +27,5 @@ unsigned to_unsigned (const char *s, const char* where);
float to_float(const char* s, const char* where); float to_float(const char* s, const char* where);
float to_probability(const char* s, const char* where); float to_probability(const char* s, const char* where);
// Parse the comma or space seperate string of numbers. // Parse the comma or space separated string of numbers.
std::vector<long> to_longs(const char* s); std::vector<long> to_longs(const char* s);

4
bin/common_trans.cc
View file

@ -980,9 +980,9 @@ static const argp_option options[] =
"atomic proposition that compatible with Spin's syntax. You can " "atomic proposition that compatible with Spin's syntax. You can "
"force this relabeling to always occur with option --relabel.\n" "force this relabeling to always occur with option --relabel.\n"
"The sequences %f,%s,%l,%w,%F,%S,%L,%W can optionally be \"infixed\"" "The sequences %f,%s,%l,%w,%F,%S,%L,%W can optionally be \"infixed\""
" by a bracketed sequence of operators to unabbreviate before outputing" " by a bracketed sequence of operators to unabbreviate before outputting"
" the formula. For instance %[MW]f will rewrite operators M and W" " the formula. For instance %[MW]f will rewrite operators M and W"
" before outputing it.\n" " before outputting it.\n"
"Furthermore, if COMMANDFMT has the form \"{NAME}CMD\", then only CMD " "Furthermore, if COMMANDFMT has the form \"{NAME}CMD\", then only CMD "
"will be passed to the shell, and NAME will be used to name the tool " "will be passed to the shell, and NAME will be used to name the tool "
"in the output.", 4 }, "in the output.", 4 },

2
bin/ltlsynt.cc
View file

@ -757,7 +757,7 @@ namespace
} }
// Takes a set of the atomic propositions appearing in the formula, // Takes a set of the atomic propositions appearing in the formula,
// and seperate them into two vectors: input APs and output APs. // and separate them into two vectors: input APs and output APs.
static std::pair<std::vector<std::string>, std::vector<std::string>> static std::pair<std::vector<std::string>, std::vector<std::string>>
filter_list_of_aps(const std::unordered_set<std::string>& aps, filter_list_of_aps(const std::unordered_set<std::string>& aps,
const char* filename, int linenum) const char* filename, int linenum)

12
bin/spot-x.cc
View file

@ -47,7 +47,7 @@ depends on the --low, --medium, or --high settings.") },
"Maximum number of states of automata involved in automata-based \ "Maximum number of states of automata involved in automata-based \
implication checks for formula simplifications. Defaults to 64.") }, implication checks for formula simplifications. Defaults to 64.") },
{ DOC("tls-max-ops", { DOC("tls-max-ops",
"Maximum number of operands in n-ary opertors (or, and) on which \ "Maximum number of operands in n-ary operators (or, and) on which \
implication-based simplifications are attempted. Defaults to 16.") }, implication-based simplifications are attempted. Defaults to 16.") },
{ nullptr, 0, nullptr, 0, "Translation options:", 0 }, { nullptr, 0, nullptr, 0, "Translation options:", 0 },
{ DOC("ltl-split", "Set to 0 to disable the translation of automata \ { DOC("ltl-split", "Set to 0 to disable the translation of automata \
@ -83,7 +83,7 @@ used when comp-susp=1 and default to 1 or 2 depending on whether --small \
or --deterministic is specified.") }, or --deterministic is specified.") },
{ nullptr, 0, nullptr, 0, "Postprocessing options:", 0 }, { nullptr, 0, nullptr, 0, "Postprocessing options:", 0 },
{ DOC("acd", "Set to 1 (the default) to use paritize automata using \ { DOC("acd", "Set to 1 (the default) to use paritize automata using \
the alternatinc cycle decomposition. Set to 0 to use paritization based \ the alternating cycle decomposition. Set to 0 to use paritization based \
on latest appearance record variants.") }, on latest appearance record variants.") },
{ DOC("scc-filter", "Set to 1 (the default) to enable \ { DOC("scc-filter", "Set to 1 (the default) to enable \
SCC-pruning and acceptance simplification at the beginning of \ SCC-pruning and acceptance simplification at the beginning of \
@ -91,7 +91,7 @@ post-processing. Transitions that are outside accepting SCC are \
removed from accepting sets, except those that enter into an accepting \ removed from accepting sets, except those that enter into an accepting \
SCC. Set to 2 to remove even these entering transition from the \ SCC. Set to 2 to remove even these entering transition from the \
accepting sets. Set to 0 to disable this SCC-pruning and acceptance \ accepting sets. Set to 0 to disable this SCC-pruning and acceptance \
simpification pass.") }, simplification pass.") },
{ DOC("degen-reset", "If non-zero (the default), the \ { DOC("degen-reset", "If non-zero (the default), the \
degeneralization algorithm will reset its level any time it exits \ degeneralization algorithm will reset its level any time it exits \
an SCC.") }, an SCC.") },
@ -121,7 +121,7 @@ level, as it might favor finding accepting cycles earlier. If \
degen-lowinit is non-zero, then level L is always used without looking \ degen-lowinit is non-zero, then level L is always used without looking \
for the presence of an accepting self-loop.") }, for the presence of an accepting self-loop.") },
{ DOC("degen-remscc", "If non-zero (the default), make sure the output \ { DOC("degen-remscc", "If non-zero (the default), make sure the output \
of the degenalization has as many SCCs as the input, by removing superfluous \ of the degeneralization has as many SCCs as the input, by removing superfluous \
ones.") }, ones.") },
{ DOC("det-max-states", "When defined to a positive integer N, \ { DOC("det-max-states", "When defined to a positive integer N, \
determinizations will be aborted whenever the number of generated \ determinizations will be aborted whenever the number of generated \
@ -180,7 +180,7 @@ attempting simulation-based reductions. Defaults to 128. Set to 0 to \
never merge states.") }, never merge states.") },
{ DOC("simul-max", "Number of states above which simulation-based \ { DOC("simul-max", "Number of states above which simulation-based \
reductions are skipped. Defaults to 4096. Set to 0 to disable. This \ reductions are skipped. Defaults to 4096. Set to 0 to disable. This \
applies to all simulation-based optimization, including thoses of the \ applies to all simulation-based optimization, including those of the \
determinization algorithm.") }, determinization algorithm.") },
{ DOC("simul-trans-pruning", "Number of equivalence classes above which \ { DOC("simul-trans-pruning", "Number of equivalence classes above which \
simulation-based transition-pruning for non-deterministic automata is \ simulation-based transition-pruning for non-deterministic automata is \
@ -259,7 +259,7 @@ sets. By default, this is only enabled when options -B or -S are used.") },
{ DOC("simul-method", { DOC("simul-method",
"Chose which simulation based reduction to use: 1 force the \ "Chose which simulation based reduction to use: 1 force the \
signature-based BDD implementation, 2 force matrix-based and 0, the default, \ signature-based BDD implementation, 2 force matrix-based and 0, the default, \
is a heristic wich choose which implementation to use.") }, is a heuristic which chooses which implementation to use.") },
{ nullptr, 0, nullptr, 0, nullptr, 0 } { nullptr, 0, nullptr, 0, nullptr, 0 }
}; };

4
spot/gen/automata.hh
View file

@ -81,7 +81,7 @@ namespace spot
/// \brief An NBA with (n+2) states derived from a Cyclic test /// \brief An NBA with (n+2) states derived from a Cyclic test
/// case. /// case.
/// ///
/// This familly of automata is derived from a couple of /// This family of automata is derived from a couple of
/// examples supplied by Reuben Rowe. The task is to /// examples supplied by Reuben Rowe. The task is to
/// check that the automaton generated with AUT_CYCLIST_TRACE_NBA /// check that the automaton generated with AUT_CYCLIST_TRACE_NBA
/// for a given n contain the automaton generated with /// for a given n contain the automaton generated with
@ -90,7 +90,7 @@ namespace spot
/// \brief A DBA with (n+2) states derived from a Cyclic test /// \brief A DBA with (n+2) states derived from a Cyclic test
/// case. /// case.
/// ///
/// This familly of automata is derived from a couple of /// This family of automata is derived from a couple of
/// examples supplied by Reuben Rowe. The task is to /// examples supplied by Reuben Rowe. The task is to
/// check that the automaton generated with AUT_CYCLIST_TRACE_NBA /// check that the automaton generated with AUT_CYCLIST_TRACE_NBA
/// for a given n contain the automaton generated with /// for a given n contain the automaton generated with

6
spot/graph/graph.hh
View file

@ -757,7 +757,7 @@ namespace spot
///@} ///@}
///@{ ///@{
/// \brief return the Edgeg_Data of an edge. /// \brief return the Edge_Data of an edge.
/// ///
/// This does not use Edge_Data& as return type, because /// This does not use Edge_Data& as return type, because
/// Edge_Data might be void. /// Edge_Data might be void.
@ -818,7 +818,7 @@ namespace spot
&& (dests_.capacity() - dests_.size()) < (sz + 1)) && (dests_.capacity() - dests_.size()) < (sz + 1))
{ {
// If dst_begin...dst_end points into dests_ and dests_ risk // If dst_begin...dst_end points into dests_ and dests_ risk
// being reallocated, we have to savea the destination // being reallocated, we have to save the destination
// states before we lose them. // states before we lose them.
std::vector<unsigned> tmp(dst_begin, dst_end); std::vector<unsigned> tmp(dst_begin, dst_end);
dests_.emplace_back(sz); dests_.emplace_back(sz);
@ -955,7 +955,7 @@ namespace spot
/// @{ /// @{
/// ///
/// \brief Return a fake container with all edges (exluding erased /// \brief Return a fake container with all edges (excluding erased
/// edges) /// edges)
internal::all_trans<const digraph> edges() const internal::all_trans<const digraph> edges() const
{ {

2
spot/ltsmin/ltsmin.hh
View file

@ -73,7 +73,7 @@ namespace spot
int compress = 0) const; int compress = 0) const;
// \brief The same as above but returns a kripkecube, i.e. a kripke // \brief The same as above but returns a kripkecube, i.e. a kripke
// that can be use in parallel. Moreover, it support more ellaborated // that can be use in parallel. Moreover, it supports more elaborated
// atomic propositions such as "P.a == P.c" // atomic propositions such as "P.a == P.c"
ltsmin_kripkecube_ptr kripkecube(std::vector<std::string> to_observe, ltsmin_kripkecube_ptr kripkecube(std::vector<std::string> to_observe,
formula dead = formula::tt(), formula dead = formula::tt(),

2
spot/ltsmin/spins_interface.hh
View file

@ -38,7 +38,7 @@ namespace spot
/// \brief Implementation of the PINS interface. This class /// \brief Implementation of the PINS interface. This class
/// is a wrapper that, given a file, will compile it w.r.t /// is a wrapper that, given a file, will compile it w.r.t
/// the PINS interface. The class can then be menipulated /// the PINS interface. The class can then be manipulated
/// transparently whatever the input format considered. /// transparently whatever the input format considered.
class SPOT_API spins_interface class SPOT_API spins_interface
{ {

2
spot/ltsmin/spins_kripke.hh
View file

@ -116,7 +116,7 @@ namespace spot
/// All successors are computed once when an iterator is recycled or /// All successors are computed once when an iterator is recycled or
/// created. /// created.
/// ///
/// Note: Two threads will explore sucessors with two different orders /// Note: Two threads will explore successors with two different orders
class cspins_iterator final class cspins_iterator final
{ {
public: public:

2
spot/mc/bloemen.hh
View file

@ -63,7 +63,7 @@ namespace spot
std::atomic<list_status> list_status_; std::atomic<list_status> list_status_;
}; };
/// \brief The haser for the previous uf_element. /// \brief The hasher for the previous uf_element.
struct uf_element_hasher struct uf_element_hasher
{ {
uf_element_hasher(const uf_element*) uf_element_hasher(const uf_element*)

2
spot/mc/bloemen_ec.hh
View file

@ -70,7 +70,7 @@ namespace spot
std::atomic<list_status> list_status_; std::atomic<list_status> list_status_;
}; };
/// \brief The haser for the previous uf_element. /// \brief The hasher for the previous uf_element.
struct uf_element_hasher struct uf_element_hasher
{ {
uf_element_hasher(const uf_element*) uf_element_hasher(const uf_element*)

6
spot/mc/cndfs.hh
View file

@ -361,7 +361,7 @@ namespace spot
todo_blue_.back().it_prop, true, tid_); todo_blue_.back().it_prop, true, tid_);
else if (acc) else if (acc)
{ {
// The state cyan and we can reach it throught an // The state cyan and we can reach it through an
// accepting transition, a accepting cycle has been // accepting transition, a accepting cycle has been
// found without launching a red dfs // found without launching a red dfs
if (tmp.second.colors->l[tid_].cyan) if (tmp.second.colors->l[tid_].cyan)
@ -499,7 +499,7 @@ namespace spot
} }
kripkecube<State, SuccIterator>& sys_; ///< \brief The system to check kripkecube<State, SuccIterator>& sys_; ///< \brief The system to check
twacube_ptr twa_; ///< \brief The propertu to check twacube_ptr twa_; ///< \brief The property to check
std::vector<todo_element> todo_blue_; ///< \brief Blue Stack std::vector<todo_element> todo_blue_; ///< \brief Blue Stack
std::vector<todo_element> todo_red_; ///< \ brief Red Stack std::vector<todo_element> todo_red_; ///< \ brief Red Stack
unsigned transitions_ = 0; ///< \brief Number of transitions unsigned transitions_ = 0; ///< \brief Number of transitions
@ -514,7 +514,7 @@ namespace spot
std::atomic<bool>& stop_; ///< \brief Stop-the-world boolean std::atomic<bool>& stop_; ///< \brief Stop-the-world boolean
std::vector<product_state> Rp_; ///< \brief Rp stack std::vector<product_state> Rp_; ///< \brief Rp stack
std::vector<product_state> Rp_acc_; ///< \brief Rp acc stack std::vector<product_state> Rp_acc_; ///< \brief Rp acc stack
product_state cycle_start_; ///< \brief Begining of a cycle product_state cycle_start_; ///< \brief Beginning of a cycle
bool finisher_ = false; bool finisher_ = false;
}; };
} }

6
spot/mc/deadlock.hh
View file

@ -37,7 +37,7 @@ namespace spot
/// \brief This class aims to explore a model to detect wether it /// \brief This class aims to explore a model to detect wether it
/// contains a deadlock. This deadlock detection performs a DFS traversal /// contains a deadlock. This deadlock detection performs a DFS traversal
/// sharing information shared among multiple threads. /// sharing information shared among multiple threads.
/// If Deadlock equals std::true_type performs dealock algorithm, /// If Deadlock equals std::true_type performs deadlock algorithm,
/// otherwise perform a simple reachability. /// otherwise perform a simple reachability.
template<typename State, typename SuccIterator, template<typename State, typename SuccIterator,
typename StateHash, typename StateEqual, typename StateHash, typename StateEqual,
@ -59,7 +59,7 @@ namespace spot
int* colors; ///< \brief the colors (one per thread) int* colors; ///< \brief the colors (one per thread)
}; };
/// \brief The haser for the previous state. /// \brief The hasher for the previous state.
struct pair_hasher struct pair_hasher
{ {
pair_hasher(const deadlock_pair*) pair_hasher(const deadlock_pair*)
@ -298,7 +298,7 @@ namespace spot
bool deadlock_ = false; ///< \brief Deadlock detected? bool deadlock_ = false; ///< \brief Deadlock detected?
std::atomic<bool>& stop_; ///< \brief Stop-the-world boolean std::atomic<bool>& stop_; ///< \brief Stop-the-world boolean
/// \brief Stack that grows according to the todo stack. It avoid multiple /// \brief Stack that grows according to the todo stack. It avoid multiple
/// concurent access to the shared map. /// concurrent access to the shared map.
std::vector<int*> refs_; std::vector<int*> refs_;
bool finisher_ = false; bool finisher_ = false;
}; };

4
spot/mc/intersect.hh
View file

@ -25,9 +25,9 @@
namespace spot namespace spot
{ {
/// \brief Find the first couple of iterator (from a given pair of /// \brief Find the first couple of iterator (from a given pair of
/// interators) that intersect. This method can be used in any /// iterators) that intersect. This method can be used in any
/// DFS/BFS-like exploration algorithm. The \a parameter indicates /// DFS/BFS-like exploration algorithm. The \a parameter indicates
/// wheter the state has just been visited since the underlying job /// whether the state has just been visited since the underlying job
/// is slightly different. /// is slightly different.
template<typename SuccIterator, typename State> template<typename SuccIterator, typename State>
static void forward_iterators(kripkecube<State, SuccIterator>& sys, static void forward_iterators(kripkecube<State, SuccIterator>& sys,

2
spot/mc/lpar13.hh
View file

@ -195,7 +195,7 @@ namespace spot
/// that a state will be popped. If the method return false, then /// that a state will be popped. If the method return false, then
/// the state will be popped. Otherwise the state \a newtop will /// the state will be popped. Otherwise the state \a newtop will
/// become the new top of the DFS stack. If the state \a top is /// become the new top of the DFS stack. If the state \a top is
/// the only one in the DFS stak, the parameter \a is_initial is set /// the only one in the DFS stack, the parameter \a is_initial is set
/// to true and both \a newtop and \a newtop_dfsnum have inconsistency /// to true and both \a newtop and \a newtop_dfsnum have inconsistency
/// values. /// values.
bool pop_state(product_state, unsigned top_dfsnum, bool, bool pop_state(product_state, unsigned top_dfsnum, bool,

10
spot/mc/mc_instanciator.hh
View file

@ -38,8 +38,8 @@ namespace spot
{ {
/// \brief This class allows to ensure (at compile time) if /// \brief This class allows to ensure (at compile time) if
/// a given parameter can be compsidered as a modelchecking algorithm /// a given parameter can be considered as a modelchecking algorithm
/// (i.e., usable by instanciate) /// (i.e., usable by instantiate)
template <typename T> template <typename T>
class SPOT_API is_a_mc_algorithm class SPOT_API is_a_mc_algorithm
{ {
@ -123,7 +123,7 @@ namespace spot
} }
#endif #endif
// Wait all threads to be instanciated. // Wait all threads to be instantiated.
while (barrier) while (barrier)
continue; continue;
swarmed[i]->run(); swarmed[i]->run();
@ -169,8 +169,8 @@ namespace spot
bool go_on = true; bool go_on = true;
for (unsigned i = 0; i < nbth && go_on; ++i) for (unsigned i = 0; i < nbth && go_on; ++i)
{ {
// Enumerate cases where a trace can be extraced // Enumerate cases where a trace can be extracted
// Here we use a switch so that adding new algortihm // Here we use a switch so that adding new algorithm
// with new return status will trigger an error that // with new return status will trigger an error that
// should the be fixed here. // should the be fixed here.
switch (result.value[i]) switch (result.value[i])

2
spot/misc/bareword.cc
View file

@ -47,7 +47,7 @@ namespace spot
} }
// This is for Spin 5. Spin 6 has a relaxed parser that can // This is for Spin 5. Spin 6 has a relaxed parser that can
// accept any parenthesized block as an atomic propoistion. // accept any parenthesized block as an atomic proposition.
bool is_spin_ap(const char* str) bool is_spin_ap(const char* str)
{ {
if (!str || !islower(*str)) if (!str || !islower(*str))

6
spot/misc/fixpool.hh
View file

@ -34,10 +34,10 @@ namespace spot
/// - Safe: ensure (when used with memcheck) that each allocation /// - Safe: ensure (when used with memcheck) that each allocation
/// is deallocated one at a time /// is deallocated one at a time
/// - Unsafe: rely on the fact that deallocating the pool also release /// - Unsafe: rely on the fact that deallocating the pool also release
/// all elements it contains. This case is usefull in a multithreaded /// all elements it contains. This case is useful in a multithreaded
/// environnement with multiple fixed_sized_pool allocating the same /// environnement with multiple fixed_sized_pool allocating the same
/// ressource. In this case it's hard to detect wich pool has allocated /// resource. In this case it's hard to detect which pool has allocated
/// some ressource. /// some resource.
enum class pool_type { Safe , Unsafe }; enum class pool_type { Safe , Unsafe };
/// A fixed-size memory pool implementation. /// A fixed-size memory pool implementation.

2
spot/misc/formater.hh
View file

@ -124,7 +124,7 @@ namespace spot
{ {
} }
/// \brief Scan the %-sequences occuring in \a fmt. /// \brief Scan the %-sequences occurring in \a fmt.
/// ///
/// Set has['c'] for each %c in \a fmt. \a has must /// Set has['c'] for each %c in \a fmt. \a has must
/// be 256 wide. /// be 256 wide.

6
spot/misc/minato.hh
View file

@ -33,14 +33,14 @@ namespace spot
class SPOT_API minato_isop class SPOT_API minato_isop
{ {
public: public:
/// \brief Conctructor. /// \brief Constructor.
/// \arg input The BDD function to translate in ISOP. /// \arg input The BDD function to translate in ISOP.
minato_isop(bdd input); minato_isop(bdd input);
/// \brief Conctructor. /// \brief Constructor.
/// \arg input The BDD function to translate in ISOP. /// \arg input The BDD function to translate in ISOP.
/// \arg vars The set of BDD variables to factorize in \a input. /// \arg vars The set of BDD variables to factorize in \a input.
minato_isop(bdd input, bdd vars); minato_isop(bdd input, bdd vars);
/// \brief Conctructor. /// \brief Constructor.
/// ///
/// This version allow some flexibility in computing the ISOP. /// This version allow some flexibility in computing the ISOP.
/// the result must be within \a input_min and \a input_max. /// the result must be within \a input_min and \a input_max.

6
spot/misc/satsolver.hh
View file

@ -69,7 +69,7 @@ namespace spot
class SPOT_API satsolver class SPOT_API satsolver
{ {
public: public:
/// \brief Construct the sat solver and itinialize variables. /// \brief Construct the sat solver and initialize variables.
/// If no satsolver is provided through SPOT_SATSOLVER env var, a /// If no satsolver is provided through SPOT_SATSOLVER env var, a
/// distributed version of PicoSAT will be used. /// distributed version of PicoSAT will be used.
satsolver(); satsolver();
@ -116,7 +116,7 @@ namespace spot
template<typename T, typename... Args> template<typename T, typename... Args>
void comment(T first, Args... args); void comment(T first, Args... args);
/// \brief Assume a litteral value. /// \brief Assume a literal value.
/// Must only be used with distributed picolib. /// Must only be used with distributed picolib.
void assume(int lit); void assume(int lit);
@ -159,7 +159,7 @@ namespace spot
int nassumptions_vars_; // Surplus of vars (for 'assume' algorithm). int nassumptions_vars_; // Surplus of vars (for 'assume' algorithm).
/// \brief Number of solutions to obtain from the satsolver /// \brief Number of solutions to obtain from the satsolver
/// (without assuming litterals). /// (without assuming literals).
int nsols_; int nsols_;
/// \brief Picosat satsolver instance. /// \brief Picosat satsolver instance.

2
spot/misc/timer.hh
View file

@ -147,7 +147,7 @@ namespace spot
return total_.cutime; return total_.cutime;
} }
/// \brief Return the system time of the current process (whithout children) /// \brief Return the system time of the current process (without children)
/// of all accumulated interval. /// of all accumulated interval.
/// ///
/// Any time interval that has been start()ed but not stop()ed /// Any time interval that has been start()ed but not stop()ed

2
spot/parseaut/public.hh
View file

@ -68,7 +68,7 @@ namespace spot
/// want_kripke. /// want_kripke.
kripke_graph_ptr ks; kripke_graph_ptr ks;
/// Whether an HOA file was termined with <code>--ABORT</code> /// Whether an HOA file was terminated with <code>--ABORT</code>
bool aborted = false; bool aborted = false;
/// Location of the automaton in the stream. /// Location of the automaton in the stream.
spot::location loc; spot::location loc;

2
spot/priv/partitioned_relabel.cc
View file

@ -88,7 +88,7 @@ bdd_partition::to_relabeling_map(twa_graph& for_me) const
bdd_partition bdd_partition
try_partition_me(const std::vector<bdd>& all_cond, unsigned max_letter) try_partition_me(const std::vector<bdd>& all_cond, unsigned max_letter)
{ {
// We create vector that will be succesively filled. // We create vector that will be successively filled.
// Each entry corresponds to a "letter", of the partition // Each entry corresponds to a "letter", of the partition
const size_t Norig = all_cond.size(); const size_t Norig = all_cond.size();

20
spot/priv/satcommon.hh
View file

@ -111,12 +111,12 @@ public:
unsigned size_nacc, unsigned size_path, bool state_based, unsigned size_nacc, unsigned size_path, bool state_based,
bool dtbasat); bool dtbasat);
/// \brief Compute min_t litteral as well as min_ta, min_p and max_p. /// \brief Compute min_t literal as well as min_ta, min_p and max_p.
/// After this step, all litterals are known. /// After this step, all literals are known.
void void
declare_all_vars(int& min_t); declare_all_vars(int& min_t);
/// \brief Return the transition's litteral corresponding to parameters. /// \brief Return the transition's literal corresponding to parameters.
inline int inline int
get_t(unsigned src, unsigned cond, unsigned dst) const get_t(unsigned src, unsigned cond, unsigned dst) const
{ {
@ -134,12 +134,12 @@ public:
return min_t_ + src * cd_mult_ + cond * size_dst_ + dst; return min_t_ + src * cd_mult_ + cond * size_dst_ + dst;
} }
/// \brief Return the transition_acc's litteral corresponding to parameters. /// \brief Return the transition_acc's literal corresponding to parameters.
/// If (state_based), all outgoing transitions use the same acceptance /// If (state_based), all outgoing transitions use the same acceptance
/// variable. Therefore, for each combination (src, nacc) there is only one /// variable. Therefore, for each combination (src, nacc) there is only one
/// litteral. /// literal.
/// Note that with Büchi automata, there is only one nacc, thus, only one /// Note that with Büchi automata, there is only one nacc, thus, only one
/// litteral for each src. /// literal for each src.
inline int inline int
get_ta(unsigned src, unsigned cond, unsigned dst, unsigned nacc = 0) const get_ta(unsigned src, unsigned cond, unsigned dst, unsigned nacc = 0) const
{ {
@ -162,7 +162,7 @@ public:
: min_ta_ + src * cdn_mult_ + cond * dn_mult_ + dst * size_nacc_ + nacc; : min_ta_ + src * cdn_mult_ + cond * dn_mult_ + dst * size_nacc_ + nacc;
} }
/// \brief Return the path's litteral corresponding to parameters. /// \brief Return the path's literal corresponding to parameters.
inline int inline int
get_p(unsigned path, unsigned src, unsigned dst) const get_p(unsigned path, unsigned src, unsigned dst) const
{ {
@ -181,9 +181,9 @@ public:
return min_p_ + path * sd_mult_ + src * size_dst_ + dst; return min_p_ + path * sd_mult_ + src * size_dst_ + dst;
} }
/// \brief Return the path's litteral corresponding to parameters. /// \brief Return the path's literal corresponding to parameters.
/// Argument ref serves to say whether it is a candidate or a reference /// Argument ref serves to say whether it is a candidate or a reference
/// litteral. false -> ref | true -> cand /// literal. false -> ref | true -> cand
inline int inline int
get_prc(unsigned path, unsigned src, unsigned dst, bool cand) const get_prc(unsigned path, unsigned src, unsigned dst, bool cand) const
{ {
@ -238,7 +238,7 @@ public:
int target_state_number, const twa_graph_ptr& res, int target_state_number, const twa_graph_ptr& res,
const satsolver& solver); const satsolver& solver);
/// \brief Returns the number of distinct values containted in a vector. /// \brief Returns the number of distinct values contained in a vector.
int int
get_number_of_distinct_vals(std::vector<unsigned> v); get_number_of_distinct_vals(std::vector<unsigned> v);
} }

8
spot/ta/ta.hh
View file

@ -111,7 +111,7 @@ namespace spot
/// \brief Get an iterator over the successors of \a state. /// \brief Get an iterator over the successors of \a state.
/// ///
/// The iterator has been allocated with \c new. It is the /// The iterator has been allocated with \c new. It is the
/// responsability of the caller to \c delete it when no /// responsibility of the caller to \c delete it when no
/// longer needed. /// longer needed.
/// ///
virtual ta_succ_iterator* virtual ta_succ_iterator*
@ -121,7 +121,7 @@ namespace spot
/// filtred by the changeset on transitions /// filtred by the changeset on transitions
/// ///
/// The iterator has been allocated with \c new. It is the /// The iterator has been allocated with \c new. It is the
/// responsability of the caller to \c delete it when no /// responsibility of the caller to \c delete it when no
/// longer needed. /// longer needed.
/// ///
virtual ta_succ_iterator* virtual ta_succ_iterator*
@ -142,7 +142,7 @@ namespace spot
/// \brief Format the state as a string for printing. /// \brief Format the state as a string for printing.
/// ///
/// This formating is the responsability of the automata /// This formatting is the responsibility of the automata
/// that owns the state. /// that owns the state.
virtual std::string virtual std::string
format_state(const spot::state* s) const = 0; format_state(const spot::state* s) const = 0;
@ -190,7 +190,7 @@ namespace spot
/// ///
/// This class provides the basic functionalities required to /// This class provides the basic functionalities required to
/// iterate over the successors of a state, as well as querying /// iterate over the successors of a state, as well as querying
/// transition labels. Because transitions are never explicitely /// transition labels. Because transitions are never explicitly
/// encoded, labels (conditions and acceptance conditions) can only /// encoded, labels (conditions and acceptance conditions) can only
/// be queried while iterating over the successors. /// be queried while iterating over the successors.
class ta_succ_iterator : public twa_succ_iterator class ta_succ_iterator : public twa_succ_iterator

4
spot/ta/taexplicit.cc
View file

@ -106,7 +106,7 @@ namespace spot
return transitions_; return transitions_;
} }
// return transitions filtred by condition // return transitions filtered by condition
state_ta_explicit::transitions* state_ta_explicit::transitions*
state_ta_explicit::get_transitions(bdd condition) const state_ta_explicit::get_transitions(bdd condition) const
{ {
@ -279,7 +279,7 @@ namespace spot
bool dest_is_livelock_accepting = bool dest_is_livelock_accepting =
dest->is_livelock_accepting_state(); dest->is_livelock_accepting_state();
//Before deleting stuttering transitions, propaged back livelock //Before deleting stuttering transitions, propagated back livelock
//and initial state's properties //and initial state's properties
if (is_stuttering_transition) if (is_stuttering_transition)
{ {

2
spot/ta/taproduct.hh
View file

@ -158,7 +158,7 @@ namespace spot
virtual bool virtual bool
is_initial_state(const spot::state* s) const override; is_initial_state(const spot::state* s) const override;
/// \brief Return true if the state \a s has no succeseurs /// \brief Return true if the state \a s has no successor
/// in the TA automaton (the TA component of the product automaton) /// in the TA automaton (the TA component of the product automaton)
bool bool
is_hole_state_in_ta_component(const spot::state* s) const; is_hole_state_in_ta_component(const spot::state* s) const;

6
spot/ta/tgta.hh
View file

@ -9,9 +9,9 @@
// (at your option) any later version. // (at your option) any later version.
// //
// Spot is distributed in the hope that it will be useful, but WITHOUT // Spot is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANta_explicitBILITY // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more deta_explicitils. // License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
@ -74,7 +74,7 @@ namespace spot
/// \a state and his successors /// \a state and his successors
/// ///
/// The iterator has been allocated with \c new. It is the /// The iterator has been allocated with \c new. It is the
/// responsability of the caller to \c delete it when no /// responsibility of the caller to \c delete it when no
/// longer needed. /// longer needed.
/// ///
virtual twa_succ_iterator* virtual twa_succ_iterator*

2
spot/taalgos/reachiter.hh
View file

@ -78,7 +78,7 @@ namespace spot
/// ///
/// \param in The source state number. /// \param in The source state number.
/// \param out The destination state number. /// \param out The destination state number.
/// \param si The spot::twa_succ_iterator positionned on the current /// \param si The spot::twa_succ_iterator positioned on the current
/// transition. /// transition.
virtual void virtual void
process_link(int in, int out, const ta_succ_iterator* si); process_link(int in, int out, const ta_succ_iterator* si);

2
spot/taalgos/tgba2ta.hh
View file

@ -37,7 +37,7 @@ namespace spot
/// \param degeneralized When false, the returned automaton is a generalized /// \param degeneralized When false, the returned automaton is a generalized
/// form of TA, called GTA (Generalized Testing Automaton). /// form of TA, called GTA (Generalized Testing Automaton).
/// Like TGBA, GTA use Generalized Büchi acceptance /// Like TGBA, GTA use Generalized Büchi acceptance
/// conditions intead of Buchi-accepting states: there are several acceptance /// conditions instead of Buchi-accepting states: there are several acceptance
/// sets (of transitions), and a path is accepted if it traverses /// sets (of transitions), and a path is accepted if it traverses
/// at least one transition of each set infinitely often or if it contains a /// at least one transition of each set infinitely often or if it contains a
/// livelock-accepting cycle (like a TA). The spot emptiness check algorithm /// livelock-accepting cycle (like a TA). The spot emptiness check algorithm

2
spot/tl/apcollect.cc
View file

@ -69,7 +69,7 @@ namespace spot
{ {
atomic_prop_set res; atomic_prop_set res;
// polirity: 0 = negative, 1 = positive, 2 or more = both. // polarity: 0 = negative, 1 = positive, 2 or more = both.
auto rec = [&res](formula f, unsigned polarity, auto self) auto rec = [&res](formula f, unsigned polarity, auto self)
{ {
switch (f.kind()) switch (f.kind())

2
spot/tl/apcollect.hh
View file

@ -57,7 +57,7 @@ namespace spot
atomic_prop_collect_as_bdd(formula f, const twa_ptr& a); atomic_prop_collect_as_bdd(formula f, const twa_ptr& a);
/// \brief Collect the literals occuring in f /// \brief Collect the literals occurring in f
/// ///
/// This function records each atomic proposition occurring in f /// This function records each atomic proposition occurring in f
/// along with the polarity of its occurrence. For instance if the /// along with the polarity of its occurrence. For instance if the

2
spot/tl/formula.cc
View file

@ -276,7 +276,7 @@ namespace spot
// pointers we should remove. We can do it in the same loop. // pointers we should remove. We can do it in the same loop.
// //
// It is simpler to construct a separate vector to do that, but that's // It is simpler to construct a separate vector to do that, but that's
// only needed if we have nested multops or null poiners. // only needed if we have nested multops or null pointers.
if (std::find_if(v.begin(), v.end(), if (std::find_if(v.begin(), v.end(),
[o](const fnode* f) { return f == nullptr || f->is(o); }) [o](const fnode* f) { return f == nullptr || f->is(o); })
!= v.end()) != v.end())

8
spot/tl/parse.hh
View file

@ -110,7 +110,7 @@ namespace spot
/// field parsed_formula::f in the returned object can be a non-zero /// field parsed_formula::f in the returned object can be a non-zero
/// value even if it encountered error during the parsing of \a /// value even if it encountered error during the parsing of \a
/// ltl_string. If you want to make sure \a ltl_string was parsed /// ltl_string. If you want to make sure \a ltl_string was parsed
/// succesfully, check \a parsed_formula::errors for emptiness. /// successfully, check \a parsed_formula::errors for emptiness.
/// ///
/// \warning This function is not reentrant. /// \warning This function is not reentrant.
SPOT_API SPOT_API
@ -133,7 +133,7 @@ namespace spot
/// field parsed_formula::f in the returned object can be a non-zero /// field parsed_formula::f in the returned object can be a non-zero
/// value even if it encountered error during the parsing of \a /// value even if it encountered error during the parsing of \a
/// ltl_string. If you want to make sure \a ltl_string was parsed /// ltl_string. If you want to make sure \a ltl_string was parsed
/// succesfully, check \a parsed_formula::errors for emptiness. /// successfully, check \a parsed_formula::errors for emptiness.
/// ///
/// \warning This function is not reentrant. /// \warning This function is not reentrant.
SPOT_API SPOT_API
@ -154,7 +154,7 @@ namespace spot
/// field parsed_formula::f in the returned object can be a non-zero /// field parsed_formula::f in the returned object can be a non-zero
/// value even if it encountered error during the parsing of \a /// value even if it encountered error during the parsing of \a
/// ltl_string. If you want to make sure \a ltl_string was parsed /// ltl_string. If you want to make sure \a ltl_string was parsed
/// succesfully, check \a parsed_formula::errors for emptiness. /// successfully, check \a parsed_formula::errors for emptiness.
/// ///
/// The LBT syntax, also used by the lbtt and scheck tools, is /// The LBT syntax, also used by the lbtt and scheck tools, is
/// extended to support W, and M operators (as done in lbtt), and /// extended to support W, and M operators (as done in lbtt), and
@ -191,7 +191,7 @@ namespace spot
/// field parsed_formula::f in the returned object can be a non-zero /// field parsed_formula::f in the returned object can be a non-zero
/// value even if it encountered error during the parsing of \a /// value even if it encountered error during the parsing of \a
/// ltl_string. If you want to make sure \a ltl_string was parsed /// ltl_string. If you want to make sure \a ltl_string was parsed
/// succesfully, check \a parsed_formula::errors for emptiness. /// successfully, check \a parsed_formula::errors for emptiness.
/// ///
/// \warning This function is not reentrant. /// \warning This function is not reentrant.
SPOT_API SPOT_API

2
spot/tl/randomltl.hh
View file

@ -200,7 +200,7 @@ namespace spot
class SPOT_API random_sere final: public random_formula class SPOT_API random_sere final: public random_formula
{ {
public: public:
/// Create a random SERE genere using atomic propositions from \a ap. /// Create a random SERE generator using atomic propositions from \a ap.
/// ///
/// The default priorities are defined as follows: /// The default priorities are defined as follows:
/// ///

2
spot/tl/relabel.hh
View file

@ -35,7 +35,7 @@ namespace spot
/// between the new names (keys) and the old names (values). /// between the new names (keys) and the old names (values).
/// ///
/// \see relabel_bse /// \see relabel_bse
/// \see relabel_overlaping_bse /// \see relabel_overlapping_bse
SPOT_API SPOT_API
formula relabel(formula f, relabeling_style style, formula relabel(formula f, relabeling_style style,
relabeling_map* m = nullptr); relabeling_map* m = nullptr);

6
spot/tl/simplify.cc
View file

@ -948,7 +948,7 @@ namespace spot
{ {
} }
// if !neg build c&X(c&X(...&X(tail))) with n occurences of c // if !neg build c&X(c&X(...&X(tail))) with n occurrences of c
// if neg build !c|X(!c|X(...|X(tail))). // if neg build !c|X(!c|X(...|X(tail))).
formula formula
dup_b_x_tail(bool neg, formula c, formula tail, unsigned n) dup_b_x_tail(bool neg, formula c, formula tail, unsigned n)
@ -1027,7 +1027,7 @@ namespace spot
// //
// The above usually make more sense when reversed (see // The above usually make more sense when reversed (see
// them in the And and Or rewritings), except when we // them in the And and Or rewritings), except when we
// try to maximaze the size of subformula that do not // try to maximize the size of subformula that do not
// have EventUniv formulae. // have EventUniv formulae.
if (opt_.favor_event_univ) if (opt_.favor_event_univ)
if (c.is(op::Or, op::And)) if (c.is(op::Or, op::And))
@ -1585,7 +1585,7 @@ namespace spot
} }
} }
} }
// {b[*i..j]} = b&X(b&X(... b)) with i occurences of b // {b[*i..j]} = b&X(b&X(... b)) with i occurrences of b
// !{b[*i..j]} = !b&X(!b&X(... !b)) // !{b[*i..j]} = !b&X(!b&X(... !b))
if (!opt_.reduce_size_strictly) if (!opt_.reduce_size_strictly)
if (c.is(op::Star)) if (c.is(op::Star))

14
spot/twa/acc.hh
View file

@ -1186,7 +1186,7 @@ namespace spot
/// \brief Convert the acceptance formula into a BDD /// \brief Convert the acceptance formula into a BDD
/// ///
/// \a map should be a vector indiced by colors, that /// \a map should be a vector indexed by colors, that
/// maps each color to the desired BDD representation. /// maps each color to the desired BDD representation.
bdd to_bdd(const bdd* map) const; bdd to_bdd(const bdd* map) const;
@ -1275,7 +1275,7 @@ namespace spot
/// Fin(i) changed to true and Inf(i) to false. /// Fin(i) changed to true and Inf(i) to false.
/// ///
/// If the condition is a disjunction and one of the disjunct /// If the condition is a disjunction and one of the disjunct
/// has the shape `...&Fin(i)&...`, then `i` will be prefered /// has the shape `...&Fin(i)&...`, then `i` will be preferred
/// over any arbitrary Fin. /// over any arbitrary Fin.
/// ///
/// The second element of the pair, is the same acceptance /// The second element of the pair, is the same acceptance
@ -1307,7 +1307,7 @@ namespace spot
/// If no disjunct has the right shape, then a random Fin(i) is /// If no disjunct has the right shape, then a random Fin(i) is
/// searched in the formula, and the output (i, left, right). /// searched in the formula, and the output (i, left, right).
/// is such that left contains all disjuncts containing Fin(i) /// is such that left contains all disjuncts containing Fin(i)
/// (at any depth), and right contains the original formlula /// (at any depth), and right contains the original formula
/// where Fin(i) has been replaced by false. /// where Fin(i) has been replaced by false.
/// @{ /// @{
std::tuple<int, acc_cond::acc_code, acc_cond::acc_code> std::tuple<int, acc_cond::acc_code, acc_cond::acc_code>
@ -1345,7 +1345,7 @@ namespace spot
/// \brief Check potential acceptance of an SCC. /// \brief Check potential acceptance of an SCC.
/// ///
/// Assuming that an SCC intersects all sets in \a /// Assuming that an SCC intersects all sets in \a
/// infinitely_often (i.e., for each set in \a infinetely_often, /// infinitely_often (i.e., for each set in \a infinitely_often,
/// there exist one marked transition in the SCC), and is /// there exist one marked transition in the SCC), and is
/// included in all sets in \a always_present (i.e., all /// included in all sets in \a always_present (i.e., all
/// transitions are marked with \a always_present), this returns /// transitions are marked with \a always_present), this returns
@ -1464,7 +1464,7 @@ namespace spot
/// "Fin(!x)" and "Inf(!x)" are not supported by this parser. /// "Fin(!x)" and "Inf(!x)" are not supported by this parser.
/// ///
/// Or the string could be the name of an acceptance condition, as /// Or the string could be the name of an acceptance condition, as
/// speficied in the HOA format. (E.g. "Rabin 2", "parity max odd 3", /// specified in the HOA format. (E.g. "Rabin 2", "parity max odd 3",
/// "generalized-Rabin 4 2 1", etc.). /// "generalized-Rabin 4 2 1", etc.).
/// ///
/// A spot::parse_error is thrown on syntax error. /// A spot::parse_error is thrown on syntax error.
@ -2190,7 +2190,7 @@ namespace spot
/// Fin(i) changed to true and Inf(i) to false. /// Fin(i) changed to true and Inf(i) to false.
/// ///
/// If the condition is a disjunction and one of the disjunct /// If the condition is a disjunction and one of the disjunct
/// has the shape `...&Fin(i)&...`, then `i` will be prefered /// has the shape `...&Fin(i)&...`, then `i` will be preferred
/// over any arbitrary Fin. /// over any arbitrary Fin.
/// ///
/// The second element of the pair, is the same acceptance /// The second element of the pair, is the same acceptance
@ -2226,7 +2226,7 @@ namespace spot
/// If no disjunct has the right shape, then a random Fin(i) is /// If no disjunct has the right shape, then a random Fin(i) is
/// searched in the formula, and the output (i, left, right). /// searched in the formula, and the output (i, left, right).
/// is such that left contains all disjuncts containing Fin(i) /// is such that left contains all disjuncts containing Fin(i)
/// (at any depth), and right contains the original formlula /// (at any depth), and right contains the original formula
/// where Fin(i) has been replaced by false. /// where Fin(i) has been replaced by false.
/// @{ /// @{
std::tuple<int, acc_cond, acc_cond> std::tuple<int, acc_cond, acc_cond>

12
spot/twa/bddprint.hh
View file

@ -40,7 +40,7 @@ namespace spot
/// This assumes that \a b is a conjunction of literals. /// This assumes that \a b is a conjunction of literals.
/// \param dict The dictionary to use, to lookup variables. /// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print. /// \param b The BDD to print.
/// \return The BDD formated as a string. /// \return The BDD formatted as a string.
SPOT_API std::string SPOT_API std::string
bdd_format_sat(const bdd_dict_ptr& dict, bdd b); bdd_format_sat(const bdd_dict_ptr& dict, bdd b);
@ -50,7 +50,7 @@ namespace spot
/// \param os The output stream. /// \param os The output stream.
/// \param dict The dictionary to use, to lookup variables. /// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print. /// \param b The BDD to print.
/// \return The BDD formated as a string. /// \return The BDD formatted as a string.
SPOT_API std::ostream& SPOT_API std::ostream&
bdd_print_accset(std::ostream& os, const bdd_dict_ptr& dict, bdd b); bdd_print_accset(std::ostream& os, const bdd_dict_ptr& dict, bdd b);
@ -59,7 +59,7 @@ namespace spot
/// This is used when saving a TGBA. /// This is used when saving a TGBA.
/// \param dict The dictionary to use, to lookup variables. /// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print. /// \param b The BDD to print.
/// \return The BDD formated as a string. /// \return The BDD formatted as a string.
SPOT_API std::string SPOT_API std::string
bdd_format_accset(const bdd_dict_ptr& dict, bdd b); bdd_format_accset(const bdd_dict_ptr& dict, bdd b);
@ -73,7 +73,7 @@ namespace spot
/// \brief Format a BDD as a set. /// \brief Format a BDD as a set.
/// \param dict The dictionary to use, to lookup variables. /// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print. /// \param b The BDD to print.
/// \return The BDD formated as a string. /// \return The BDD formatted as a string.
SPOT_API std::string SPOT_API std::string
bdd_format_set(const bdd_dict_ptr& dict, bdd b); bdd_format_set(const bdd_dict_ptr& dict, bdd b);
@ -87,7 +87,7 @@ namespace spot
/// \brief Format a BDD as a formula. /// \brief Format a BDD as a formula.
/// \param dict The dictionary to use, to lookup variables. /// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print. /// \param b The BDD to print.
/// \return The BDD formated as a string. /// \return The BDD formatted as a string.
SPOT_API std::string SPOT_API std::string
bdd_format_formula(const bdd_dict_ptr& dict, bdd b); bdd_format_formula(const bdd_dict_ptr& dict, bdd b);
@ -98,7 +98,7 @@ namespace spot
/// \brief Format a BDD as an irredundant sum of product. /// \brief Format a BDD as an irredundant sum of product.
/// \param dict The dictionary to use, to lookup variables. /// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print. /// \param b The BDD to print.
/// \return The BDD formated as a string. /// \return The BDD formatted as a string.
SPOT_API std::string SPOT_API std::string
bdd_format_isop(const bdd_dict_ptr& dict, bdd b); bdd_format_isop(const bdd_dict_ptr& dict, bdd b);

2
spot/twa/formula2bdd.cc
View file

@ -25,7 +25,7 @@ namespace spot
{ {
namespace namespace
{ {
// Convert a BDD which is known to be a conjonction into a formula. // Convert a BDD which is known to be a conjunction into a formula.
// If dual is true, dualize the result, i.e., negate literals, and // If dual is true, dualize the result, i.e., negate literals, and
// exchange ∧ and ∨. // exchange ∧ and ∨.
template<bool dual> template<bool dual>

8
spot/twa/twa.hh
View file

@ -630,14 +630,14 @@ namespace spot
/// \brief Get the initial state of the automaton. /// \brief Get the initial state of the automaton.
/// ///
/// The state has been allocated with \c new. It is the /// The state has been allocated with \c new. It is the
/// responsability of the caller to \c destroy it when no /// responsibility of the caller to \c destroy it when no
/// longer needed. /// longer needed.
virtual const state* get_init_state() const = 0; virtual const state* get_init_state() const = 0;
/// \brief Get an iterator over the successors of \a local_state. /// \brief Get an iterator over the successors of \a local_state.
/// ///
/// The iterator has been allocated with \c new. It is the /// The iterator has been allocated with \c new. It is the
/// responsability of the caller to \c delete it when no /// responsibility of the caller to \c delete it when no
/// longer needed. /// longer needed.
/// ///
/// \see succ() /// \see succ()
@ -785,7 +785,7 @@ namespace spot
/// \brief Format the state as a string for printing. /// \brief Format the state as a string for printing.
/// ///
/// Formating is the responsability of the automata that owns the /// Formatting is the responsibility of the automata that owns the
/// state, so that state objects could be implemented as very /// state, so that state objects could be implemented as very
/// small objects, maybe sharing data with other state objects via /// small objects, maybe sharing data with other state objects via
/// data structure stored in the automaton. /// data structure stored in the automaton.
@ -795,7 +795,7 @@ namespace spot
/// ///
/// This converts \a s, into that corresponding spot::state for \a /// This converts \a s, into that corresponding spot::state for \a
/// t. This is useful when you have the state of a product, and /// t. This is useful when you have the state of a product, and
/// want to restrict this state to a specific automata occuring in /// want to restrict this state to a specific automata occurring in
/// the product. /// the product.
/// ///
/// It goes without saying that \a s and \a t should be compatible /// It goes without saying that \a s and \a t should be compatible

8
spot/twa/twagraph.cc
View file

@ -412,7 +412,7 @@ namespace spot
// (We will use two hash maps in this case.) // (We will use two hash maps in this case.)
auto sp = get_named_prop<std::vector<bool>>("state-player"); auto sp = get_named_prop<std::vector<bool>>("state-player");
// The hashing is a bit delicat: We may only use the dst if it has // The hashing is a bit delicate: We may only use the dst if it has
// no self-loop. HASH_OF_STATE stores the hash associated to each // no self-loop. HASH_OF_STATE stores the hash associated to each
// state (by default its own number) or some common value if the // state (by default its own number) or some common value if the
// state contains self-loop. // state contains self-loop.
@ -505,7 +505,7 @@ namespace spot
} }
// All states that might possible be merged share the same hash // All states that might possible be merged share the same hash
// Info hash coll // Info hash coll
//std::cout << "Hash collission rate pre merge: " //std::cout << "Hash collision rate pre merge: "
// << ((map0.size()+map1.size())/((float)n_states)) // << ((map0.size()+map1.size())/((float)n_states))
// << '\n'; // << '\n';
@ -561,7 +561,7 @@ namespace spot
sl1 = e_chain[sl1]; sl1 = e_chain[sl1];
sl2 = e_chain[sl2]; sl2 = e_chain[sl2];
} }
// Since edges are ordered on each side, aadvance // Since edges are ordered on each side, advance
// the smallest side in case there is no match. // the smallest side in case there is no match.
else if (edge_data_comp(data1, data2)) else if (edge_data_comp(data1, data2))
sl1 = e_chain[sl1]; sl1 = e_chain[sl1];
@ -747,7 +747,7 @@ namespace spot
if (merged) if (merged)
defrag_states(remap, st); defrag_states(remap, st);
// Info hash coll 2 // Info hash coll 2
//std::cout << "Hash collission rate post merge: " //std::cout << "Hash collision rate post merge: "
// << ((map0.size()+map1.size())/((float)num_states())) // << ((map0.size()+map1.size())/((float)num_states()))
// << '\n'; // << '\n';
return merged; return merged;

2
spot/twa/twagraph.hh
View file

@ -600,7 +600,7 @@ namespace spot
/// the edges /// the edges
/// \param to_merge_ptr Determines which states are candidates. /// \param to_merge_ptr Determines which states are candidates.
/// If null, all states are considered /// If null, all states are considered
/// The actual implementation differd from merge_states(). /// The actual implementation differs from merge_states().
/// It is more costly, but is more precise, in the sense that /// It is more costly, but is more precise, in the sense that
/// more states are merged. /// more states are merged.
unsigned merge_states_of(bool stable = true, unsigned merge_states_of(bool stable = true,

4
spot/twaalgos/aiger.cc
View file

@ -1031,7 +1031,7 @@ namespace spot
it2.first.first.id(), it2.first.first.id(),
it2.first.second.id()); }); it2.first.second.id()); });
if (itm == occur_map.cend()) if (itm == occur_map.cend())
throw std::runtime_error("Empty occurence map"); throw std::runtime_error("Empty occurrence map");
return *itm; return *itm;
}; };
@ -1180,7 +1180,7 @@ namespace spot
// Create all the bdds/vars // Create all the bdds/vars
// true/false/latches/inputs already exist // true/false/latches/inputs already exist
// Get the gatenumber corresponding to an output // Get the gate number corresponding to an output
auto v2g = [&](unsigned v)->unsigned auto v2g = [&](unsigned v)->unsigned
{ {
v = circ.aig_pos(v); v = circ.aig_pos(v);

4
spot/twaalgos/aiger.hh
View file

@ -86,7 +86,7 @@ namespace spot
public: public:
/// \brief Mark the beginning of a test tranlation /// \brief Mark the beginning of a test translation
/// ///
/// Sometimes different encodings produces more or less gates. /// Sometimes different encodings produces more or less gates.
/// To improve performances, one can "safe" the current status /// To improve performances, one can "safe" the current status
@ -297,7 +297,7 @@ namespace spot
/// \param method How to translate the bdd. 0: If-then-else normal form, /// \param method How to translate the bdd. 0: If-then-else normal form,
/// 1: isop normal form, 2: try both and retain smaller /// 1: isop normal form, 2: try both and retain smaller
/// \param use_dual Encode the negations of the given bdds and /// \param use_dual Encode the negations of the given bdds and
/// retain the smalles implementation /// retain the smallest implementation
/// \param use_split_off 0: Use base algo /// \param use_split_off 0: Use base algo
/// 1: Separate the different types of input signals /// 1: Separate the different types of input signals
/// (like latches, inputs) to increase gate /// (like latches, inputs) to increase gate

2
spot/twaalgos/alternation.hh
View file

@ -40,7 +40,7 @@ namespace spot
/// ///
/// operator() can be called on states with universal branching /// operator() can be called on states with universal branching
/// (that's actually the point), and can be called on state number /// (that's actually the point), and can be called on state number
/// that designate groupes of destination states (in that case the /// that designate groups of destination states (in that case the
/// conjunction of all those states are taken). /// conjunction of all those states are taken).
class SPOT_API outedge_combiner class SPOT_API outedge_combiner
{ {

2
spot/twaalgos/cleanacc.cc
View file

@ -549,7 +549,7 @@ namespace spot
for (auto& e: aut->edges()) for (auto& e: aut->edges())
{ {
// Just avoit the e.acc.sets() loops on marks that we have // Just avoid the e.acc.sets() loops on marks that we have
// just seen. // just seen.
if (e.acc == previous_a) if (e.acc == previous_a)
continue; continue;

2
spot/twaalgos/cobuchi.cc
View file

@ -408,7 +408,7 @@ namespace spot
// Each state is characterized by a bitvect_array of 2 bitvects: // Each state is characterized by a bitvect_array of 2 bitvects:
// bv1 -> the set of original states that it represents // bv1 -> the set of original states that it represents
// bv2 -> a set of marked states (~) // bv2 -> a set of marked states (~)
// To do so, we keep a correspondance between a state number and its // To do so, we keep a correspondence between a state number and its
// bitvect representation. // bitvect representation.
dca_st_mapping bv_to_num_; dca_st_mapping bv_to_num_;
std::vector<std::pair<unsigned, bitvect_array*>> num_2_bv_; std::vector<std::pair<unsigned, bitvect_array*>> num_2_bv_;

4
spot/twaalgos/contains.cc
View file

@ -80,14 +80,14 @@ namespace spot
bool are_equivalent(const_twa_graph_ptr left, formula right) bool are_equivalent(const_twa_graph_ptr left, formula right)
{ {
// The first containement check does not involve a // The first containment check does not involve a
// complementation, the second might. // complementation, the second might.
return contains(left, right) && contains(right, left); return contains(left, right) && contains(right, left);
} }
bool are_equivalent(formula left, const_twa_graph_ptr right) bool are_equivalent(formula left, const_twa_graph_ptr right)
{ {
// The first containement check does not involve a // The first containment check does not involve a
// complementation, the second might. // complementation, the second might.
return contains(right, left) && contains(left, right); return contains(right, left) && contains(left, right);
} }

4
spot/twaalgos/couvreurnew.cc
View file

@ -282,7 +282,7 @@ namespace spot
const_twa_ptr>::type; const_twa_ptr>::type;
// The status of the emptiness-check on success. // The status of the emptiness-check on success.
// It contains everyting needed to build a counter-example: // It contains everything needed to build a counter-example:
// the automaton, the stack of SCCs traversed by the counter-example, // the automaton, the stack of SCCs traversed by the counter-example,
// and the heap of visited states with their indices. // and the heap of visited states with their indices.
template<bool is_explicit> template<bool is_explicit>
@ -579,7 +579,7 @@ namespace spot
return check_impl<true>(); return check_impl<true>();
} }
// The following two methods anticipe the future interface of the // The following two methods anticipate the future interface of the
// class emptiness_check. Following the interface of twa, the class // class emptiness_check. Following the interface of twa, the class
// emptiness_check_result should not be exposed. // emptiness_check_result should not be exposed.
bool bool

2
spot/twaalgos/cycles.hh
View file

@ -43,7 +43,7 @@ namespace spot
/// ///
/// We represent a cycle by a sequence of succ_iterator objects /// We represent a cycle by a sequence of succ_iterator objects
/// positioned on the transition contributing to the cycle. These /// positioned on the transition contributing to the cycle. These
/// succ_itertor are stored, along with their source state, in the /// succ_iterator are stored, along with their source state, in the
/// dfs_ stack. Only the last portion of this stack may form a /// dfs_ stack. Only the last portion of this stack may form a
/// cycle. /// cycle.
/// ///

6
spot/twaalgos/degen.cc
View file

@ -32,7 +32,7 @@ namespace spot
{ {
namespace namespace
{ {
// A state in the degenalized automaton corresponds to a state in // A state in the degeneralized automaton corresponds to a state in
// the TGBA associated to a level. The level is just an index in // the TGBA associated to a level. The level is just an index in
// the list of acceptance sets. // the list of acceptance sets.
typedef std::pair<unsigned, unsigned> degen_state; typedef std::pair<unsigned, unsigned> degen_state;
@ -495,7 +495,7 @@ namespace spot
levels->emplace_back(ds.second); levels->emplace_back(ds.second);
// Level cache stores one encountered level for each state // Level cache stores one encountered level for each state
// (the value of use_lvl_cache determinates which level // (the value of use_lvl_cache determines which level
// should be remembered). This cache is used when // should be remembered). This cache is used when
// re-entering the SCC. // re-entering the SCC.
if (use_lvl_cache) if (use_lvl_cache)
@ -579,7 +579,7 @@ namespace spot
// where 1 is initial and => marks accepting // where 1 is initial and => marks accepting
// edges: 1=>1, 1=>2, 2->2, 2->1. This is // edges: 1=>1, 1=>2, 2->2, 2->1. This is
// already an SBA, with 1 as accepting state. // already an SBA, with 1 as accepting state.
// However if you try degeralize it without // However if you try degeneralize it without
// ignoring *prev, you'll get two copies of state // ignoring *prev, you'll get two copies of state
// 2, depending on whether we reach it using 1=>2 // 2, depending on whether we reach it using 1=>2
// or from 2->2. If this example was not clear, // or from 2->2. If this example was not clear,

8
spot/twaalgos/degen.hh
View file

@ -28,7 +28,7 @@ namespace spot
/// \brief Degeneralize a generalized (co)Büchi automaton into an /// \brief Degeneralize a generalized (co)Büchi automaton into an
/// equivalent (co)Büchi automaton. /// equivalent (co)Büchi automaton.
/// ///
/// There are two variants of the function. If the generalizd /// There are two variants of the function. If the generalized
/// (co)Büchi acceptance uses N colors, degeneralize() algorithm /// (co)Büchi acceptance uses N colors, degeneralize() algorithm
/// will builds a state-based (co)Büchi automaton that has at most /// will builds a state-based (co)Büchi automaton that has at most
/// (N+1) times the number of states of the original automaton. /// (N+1) times the number of states of the original automaton.
@ -38,12 +38,12 @@ namespace spot
/// ///
/// Additional options control optimizations described in /// Additional options control optimizations described in
/// \cite babiak.13.spin . When \a use_z_lvl is set, the level of /// \cite babiak.13.spin . When \a use_z_lvl is set, the level of
/// the degeneralized automaton is reset everytime an SCC is exited. /// the degeneralized automaton is reset every time an SCC is exited.
/// If \a use_cust_acc_orders is set, the degeneralization will /// If \a use_cust_acc_orders is set, the degeneralization will
/// compute a custom acceptance order for each SCC (this option is /// compute a custom acceptance order for each SCC (this option is
/// disabled by default because our benchmarks show that it usually /// disabled by default because our benchmarks show that it usually
/// does more harm than good). If \a use_lvl_cache is set, /// does more harm than good). If \a use_lvl_cache is set,
/// everytime an SCC is entered on a state that as already been /// every time an SCC is entered on a state that as already been
/// associated to some level elsewhere, reuse that level (set it to /// associated to some level elsewhere, reuse that level (set it to
/// 2 to keep the smallest number, 3 to keep the largest level, and /// 2 to keep the smallest number, 3 to keep the largest level, and
/// 1 to keep the first level found). If \a ignaccsl is set, we do /// 1 to keep the first level found). If \a ignaccsl is set, we do
@ -75,7 +75,7 @@ namespace spot
/// ///
/// As an alternative method to degeneralization, one may also /// As an alternative method to degeneralization, one may also
/// consider ACD transform. acd_transform() will never produce /// consider ACD transform. acd_transform() will never produce
/// larger automata than degenaralize_tba(), and /// larger automata than degeneralize_tba(), and
/// acd_transform_sbacc() produce smaller automata than /// acd_transform_sbacc() produce smaller automata than
/// degeneralize() on the average. See \cite casares.22.tacas for /// degeneralize() on the average. See \cite casares.22.tacas for
/// some comparisons. /// some comparisons.

2
spot/twaalgos/dot.hh
View file

@ -29,7 +29,7 @@ namespace spot
/// \brief Print reachable states in dot format. /// \brief Print reachable states in dot format.
/// ///
/// If \a assume_sba is set, this assumes that the automaton /// If \a assume_sba is set, this assumes that the automaton
/// is an SBA and use double elipse to mark accepting states. /// is an SBA and use double ellipse to mark accepting states.
/// ///
/// \param options an optional string of letters, each indicating a /// \param options an optional string of letters, each indicating a
/// different option. Presently the following options are /// different option. Presently the following options are

12
spot/twaalgos/dtbasat.cc
View file

@ -243,7 +243,7 @@ namespace spot
// it is necessary to associate to each path constructed, an ID number. // it is necessary to associate to each path constructed, an ID number.
// //
// Given this ID, src_cand, dst_cand and a boolean that tells we want // Given this ID, src_cand, dst_cand and a boolean that tells we want
// ref or cand var, the corresponding litteral can be retrieved thanks // ref or cand var, the corresponding literal can be retrieved thanks
// to get_prc(...), a vars_helper's method. // to get_prc(...), a vars_helper's method.
unsigned path_size = 0; unsigned path_size = 0;
for (unsigned i = 0; i < d.ref_size; ++i) for (unsigned i = 0; i < d.ref_size; ++i)
@ -264,8 +264,8 @@ namespace spot
} }
} }
// Fill dict's bdd vetor (alpha_vect) and save each bdd and it's // Fill dict's bdd vector (alpha_vect) and save each bdd and it's
// corresponding index in alpha_map. This is necessary beacause // corresponding index in alpha_map. This is necessary because
// some loops start from a precise bdd. Therefore, it's useful // some loops start from a precise bdd. Therefore, it's useful
// to know its corresponding index to deal with vars_helper. // to know its corresponding index to deal with vars_helper.
unsigned j = 0; unsigned j = 0;
@ -281,7 +281,7 @@ namespace spot
d.helper.init(d.cand_size, d.alpha_vect.size(), d.cand_size, d.helper.init(d.cand_size, d.alpha_vect.size(), d.cand_size,
1, path_size, state_based, true); 1, path_size, state_based, true);
// Based on all previous informations, helper knows all litterals. // Based on all previous informations, helper knows all literals.
d.helper.declare_all_vars(++d.nvars); d.helper.declare_all_vars(++d.nvars);
} }
@ -399,7 +399,7 @@ namespace spot
const acc_cond& ra = ref->acc(); const acc_cond& ra = ref->acc();
// construction of contraints (4,5) : all loops in the product // construction of constraints (4,5) : all loops in the product
// where no accepting run is detected in the ref. automaton, // where no accepting run is detected in the ref. automaton,
// must also be marked as not accepting in the cand. automaton // must also be marked as not accepting in the cand. automaton
for (unsigned q1p = 0; q1p < d.ref_size; ++q1p) for (unsigned q1p = 0; q1p < d.ref_size; ++q1p)
@ -473,7 +473,7 @@ namespace spot
} }
} }
} }
// construction of contraints (6,7): all loops in the product // construction of constraints (6,7): all loops in the product
// where accepting run is detected in the ref. automaton, must // where accepting run is detected in the ref. automaton, must
// also be marked as accepting in the candidate. // also be marked as accepting in the candidate.
for (unsigned q1p = 0; q1p < d.ref_size; ++q1p) for (unsigned q1p = 0; q1p < d.ref_size; ++q1p)

12
spot/twaalgos/dtwasat.cc
View file

@ -459,8 +459,8 @@ namespace spot
// refhist, it is necessary to associate to each path constructed, // refhist, it is necessary to associate to each path constructed,
// an ID number. // an ID number.
// //
// Given this ID, src_cand, dst_cand, the corresponding litteral can be // Given this ID, src_cand, dst_cand, the corresponding literal can be
// retrived thanks to get_prc(...) a vars_helper's method. // retrieved thanks to get_prc(...) a vars_helper's method.
unsigned path_size = 0; unsigned path_size = 0;
for (unsigned i = 0; i < d.ref_size; ++i) for (unsigned i = 0; i < d.ref_size; ++i)
{ {
@ -493,8 +493,8 @@ namespace spot
} }
} }
// Fill dict's bdd vetor (alpha_vect) and save each bdd and it's // Fill dict's bdd vector (alpha_vect) and save each bdd and it's
// corresponding index in alpha_map. This is necessary beacause // corresponding index in alpha_map. This is necessary because
// some loops start from a precise bdd. Therefore, it's useful // some loops start from a precise bdd. Therefore, it's useful
// to know its corresponding index to deal with vars_helper. // to know its corresponding index to deal with vars_helper.
unsigned j = 0; unsigned j = 0;
@ -510,7 +510,7 @@ namespace spot
d.helper.init(d.cand_size, d.alpha_vect.size(), d.cand_size, d.helper.init(d.cand_size, d.alpha_vect.size(), d.cand_size,
d.cand_nacc, path_size, state_based, false); d.cand_nacc, path_size, state_based, false);
// Based on all previous informations, helper knows all litterals. // Based on all previous informations, helper knows all literals.
d.helper.declare_all_vars(++d.nvars); d.helper.declare_all_vars(++d.nvars);
} }
@ -909,7 +909,7 @@ namespace spot
dout << "--- transition_acc variables ---\n"; dout << "--- transition_acc variables ---\n";
if (state_based) if (state_based)
{ {
dout << "In state_based mode, there is only 1 litteral for each " dout << "In state_based mode, there is only 1 literal for each "
"combination of src and nacc, regardless of dst or cond!\n"; "combination of src and nacc, regardless of dst or cond!\n";
for (unsigned i = 0; i < satdict.cand_size; ++i) for (unsigned i = 0; i < satdict.cand_size; ++i)
for (unsigned j = 0; j < satdict.cand_nacc; ++j) for (unsigned j = 0; j < satdict.cand_nacc; ++j)

2
spot/twaalgos/dtwasat.hh
View file

@ -85,7 +85,7 @@ namespace spot
/// \brief Attempt to minimize a deterministic TωA with a SAT solver. /// \brief Attempt to minimize a deterministic TωA with a SAT solver.
/// ///
/// It acts like dtwa_sat_synthetisze() and obtains a first minimized /// It acts like dtwa_sat_synthetize() and obtains a first minimized
/// automaton. Then, incrementally, it encodes and solves the deletion of one /// automaton. Then, incrementally, it encodes and solves the deletion of one
/// state as many time as param value. /// state as many time as param value.
/// If param >= 0, this process is fully repeated until the minimal automaton /// If param >= 0, this process is fully repeated until the minimal automaton

2
spot/twaalgos/dualize.cc
View file

@ -177,7 +177,7 @@ namespace spot
} }
}; };
// Iterating over all mineterms can be very slow when |AP| // Iterating over all minterms can be very slow when |AP|
// is large (see issue #566) . The else branch implements // is large (see issue #566) . The else branch implements
// another approach that should be exponential in the // another approach that should be exponential in the
// number of successors instead of in the number of atomic // number of successors instead of in the number of atomic

4
spot/twaalgos/emptiness.hh
View file

@ -112,7 +112,7 @@ namespace spot
return a_; return a_;
} }
/// Return the options parametrizing how the accepting run is computed. // / Return the options parameterizing how the accepting run is computed.
const option_map& const option_map&
options() const options() const
{ {
@ -153,7 +153,7 @@ namespace spot
return a_; return a_;
} }
/// Return the options parametrizing how the emptiness check is realized. /// Return the options parameterizing how the emptiness check is realized.
const option_map& const option_map&
options() const options() const
{ {

2
spot/twaalgos/emptiness_stats.hh
View file

@ -127,7 +127,7 @@ namespace spot
} }
private : private :
unsigned states_; /// number of disctint visited states unsigned states_; /// number of distinct visited states
unsigned transitions_; /// number of visited transitions unsigned transitions_; /// number of visited transitions
unsigned depth_; /// maximal depth of the stack(s) unsigned depth_; /// maximal depth of the stack(s)
unsigned max_depth_; /// maximal depth of the stack(s) unsigned max_depth_; /// maximal depth of the stack(s)

8
spot/twaalgos/game.cc
View file

@ -491,7 +491,7 @@ namespace spot
bool acc_par, par_t min_win_par, bool respect_sg=true) bool acc_par, par_t min_win_par, bool respect_sg=true)
{ {
// In fix_scc, the attr computation is // In fix_scc, the attr computation is
// abused so we can not check ertain things // abused so we can not check certain things
// Computes the attractor of the winning set of player p within a // Computes the attractor of the winning set of player p within a
// subgame given as rd. // subgame given as rd.
// If acc_par is true, max_par transitions are also accepting and // If acc_par is true, max_par transitions are also accepting and
@ -860,7 +860,7 @@ namespace spot
// during construction // during construction
std::vector<strat_t> s_; std::vector<strat_t> s_;
// Informations about sccs andthe current scc // Informations about sccs and the current scc
std::unique_ptr<scc_info> info_; std::unique_ptr<scc_info> info_;
par_t max_abs_par_; // Max parity occurring in the current scc par_t max_abs_par_; // Max parity occurring in the current scc
// Minimal and maximal parity occurring in the entire graph // Minimal and maximal parity occurring in the entire graph
@ -1112,7 +1112,7 @@ namespace spot
if (owners->size() != arena->num_states()) if (owners->size() != arena->num_states())
throw std::runtime_error("set_state_player(): The \"state-player\" " throw std::runtime_error("set_state_player(): The \"state-player\" "
"vector has a different " "vector has a different "
"size comparerd to the automaton! " "size compared to the automaton! "
"Called new_state in between?"); "Called new_state in between?");
(*owners)[state] = owner; (*owners)[state] = owner;
@ -1286,7 +1286,7 @@ namespace spot
game->set_named_prop("strategy", strategy); game->set_named_prop("strategy", strategy);
// transposed is a reversed copy of game to compute predecessors // transposed is a reversed copy of game to compute predecessors
// more easily. It also keep track of the original edge iindex. // more easily. It also keep track of the original edge index.
struct edge_data { struct edge_data {
unsigned edgeidx; unsigned edgeidx;
}; };

2
spot/twaalgos/genem.hh
View file

@ -114,7 +114,7 @@ namespace spot
/// Give the set of transitions contained in /// Give the set of transitions contained in
/// an accepting cycle of the SCC \a scc of \a aut. /// an accepting cycle of the SCC \a scc of \a aut.
/// ///
/// \param si scc_info used to describle the automaton /// \param si scc_info used to describe the automaton
/// \param scc SCC to consider /// \param scc SCC to consider
/// \param aut_acc Acceptance condition used for this SCC /// \param aut_acc Acceptance condition used for this SCC
/// \param removed_colors A set of colors that can't appear on a transition /// \param removed_colors A set of colors that can't appear on a transition

2
spot/twaalgos/hoa.hh
View file

@ -153,7 +153,7 @@ namespace spot
/// \brief Retrieve the list of aliases. /// \brief Retrieve the list of aliases.
/// ///
/// This points to the same list that the automaton's "aliasaes" /// This points to the same list that the automaton's "aliases"
/// named properties points to. Will return `nullptr` if no /// named properties points to. Will return `nullptr` if no
/// aliases are defined. /// aliases are defined.
/// ///

4
spot/twaalgos/langmap.hh
View file

@ -26,8 +26,8 @@ namespace spot
/// \brief Identify states that recognize the same language. /// \brief Identify states that recognize the same language.
/// ///
/// The returned vector is the same size as the automaton's number of state. /// The returned vector is the same size as the automaton's number of state.
/// The number of different values (ignoring occurences) in the vector is the // / The number of different values (ignoring occurrences) in the vector is
/// total number of recognized languages, states recognizing the same /// the total number of recognized languages, states recognizing the same
/// language have the same value. /// language have the same value.
/// ///
/// The given automaton must be deterministic. /// The given automaton must be deterministic.

2
spot/twaalgos/ltl2tgba_fm.hh
View file

@ -67,7 +67,7 @@ namespace spot
/// for the type of reduction you want, see spot::tl_simplifier. /// for the type of reduction you want, see spot::tl_simplifier.
/// This idea is taken from \cite thirioux.02.fmics . /// This idea is taken from \cite thirioux.02.fmics .
/// ///
/// \param unambiguous When true, unambigous TGBA will be produced /// \param unambiguous When true, unambiguous TGBA will be produced
/// using the trick described in \cite benedikt.13.tacas . /// using the trick described in \cite benedikt.13.tacas .
/// ///
/// \param aborter When given, aborts the construction whenever the /// \param aborter When given, aborts the construction whenever the

4
spot/twaalgos/magic.cc
View file

@ -211,7 +211,7 @@ namespace spot
// the test 'c.get_color() != RED' is added to limit // the test 'c.get_color() != RED' is added to limit
// the number of runs reported by successive // the number of runs reported by successive
// calls to the check method. Without this // calls to the check method. Without this
// functionnality, the test can be ommited. // functionality, the test can be omitted.
trace << " It is blue and the arc is " trace << " It is blue and the arc is "
<< "accepting, start a red dfs" << std::endl; << "accepting, start a red dfs" << std::endl;
target = f.s; target = f.s;
@ -242,7 +242,7 @@ namespace spot
// the test 'c.get_color() != RED' is added to limit // the test 'c.get_color() != RED' is added to limit
// the number of runs reported by successive // the number of runs reported by successive
// calls to the check method. Without this // calls to the check method. Without this
// functionnality, the test can be ommited. // functionality, the test can be omitted.
trace << " It is blue and the arc from " trace << " It is blue and the arc from "
<< a_->format_state(st_blue.front().s) << a_->format_state(st_blue.front().s)
<< " to it is accepting, start a red dfs" << " to it is accepting, start a red dfs"

6
spot/twaalgos/magic.hh
View file

@ -33,7 +33,7 @@ namespace spot
/// \pre The automaton \a a must have at most one acceptance condition (i.e. /// \pre The automaton \a a must have at most one acceptance condition (i.e.
/// it is a TBA). /// it is a TBA).
/// ///
/// During the visit of \a a, the returned checker stores explicitely all /// During the visit of \a a, the returned checker stores explicitly all
/// the traversed states. /// the traversed states.
/// The method \a check() of the checker can be called several times /// The method \a check() of the checker can be called several times
/// (until it returns a null pointer) to enumerate all the visited acceptance /// (until it returns a null pointer) to enumerate all the visited acceptance
@ -88,11 +88,11 @@ namespace spot
/// \pre The automaton \a a must have at most one acceptance condition (i.e. /// \pre The automaton \a a must have at most one acceptance condition (i.e.
/// it is a TBA). /// it is a TBA).
/// ///
/// During the visit of \a a, the returned checker does not store explicitely /// During the visit of \a a, the returned checker does not store explicitly
/// the traversed states but uses the bit-state hashing technic presented in: /// the traversed states but uses the bit-state hashing technic presented in:
/// \cite Holzmann.91.book. /// \cite Holzmann.91.book.
/// ///
/// Consequently, the detection of an acceptence cycle is not ensured. /// Consequently, the detection of an acceptance cycle is not ensured.
/// ///
/// The size of the heap is limited to \n size bytes. /// The size of the heap is limited to \n size bytes.
/// ///

4
spot/twaalgos/mask.hh
View file

@ -136,7 +136,7 @@ namespace spot
/// </code> /// </code>
/// It can modify either the condition or the acceptance sets of /// It can modify either the condition or the acceptance sets of
/// the edges. Set the condition to bddfalse to remove it. Note that /// the edges. Set the condition to bddfalse to remove it. Note that
/// all transtions will be processed. /// all transitions will be processed.
/// \param init The optional new initial state. /// \param init The optional new initial state.
template<typename Trans> template<typename Trans>
void transform_copy(const const_twa_graph_ptr& old, void transform_copy(const const_twa_graph_ptr& old,
@ -157,7 +157,7 @@ namespace spot
acc_cond::mark_t acc = t.acc; acc_cond::mark_t acc = t.acc;
trans(t.src, cond, acc, t.dst); trans(t.src, cond, acc, t.dst);
// Having the same number of states should assure that state ids are // Having the same number of states should assure that state ids are
// equivilent in old and cpy. // equivalent in old and cpy.
SPOT_ASSERT(t.src < cpy->num_states() && t.dst < cpy->num_states()); SPOT_ASSERT(t.src < cpy->num_states() && t.dst < cpy->num_states());
if (cond != bddfalse) if (cond != bddfalse)
cpy->new_edge(t.src, t.dst, cond, acc); cpy->new_edge(t.src, t.dst, cond, acc);

4
spot/twaalgos/mealy_machine.cc
View file

@ -99,7 +99,7 @@ namespace
{ {
if (!f) if (!f)
throw std::runtime_error("`" + name + throw std::runtime_error("`" + name +
"' could not be oppened for writing."); "' could not be opened for writing.");
} }
~fwrapper() ~fwrapper()
{ {
@ -257,7 +257,7 @@ namespace spot
if (!is_deterministic_(ins)) if (!is_deterministic_(ins))
{ {
trace << "is_input_deterministic_mealy(): State number " trace << "is_input_deterministic_mealy(): State number "
<< s << " is not input determinisc!\n"; << s << " is not input determinist!\n";
return false; return false;
} }
} }

4
spot/twaalgos/mealy_machine.hh
View file

@ -91,7 +91,7 @@ namespace spot
/// \brief split a separated mealy machine /// \brief split a separated mealy machine
/// ///
/// In a separated mealy machine, every transitions as a label of /// In a separated mealy machine, every transitions as a label of
/// the form `(in)&(out)`. This function will turn each transtion /// the form `(in)&(out)`. This function will turn each transition
/// into a pair of consecutive transitions labeled by `in` and /// into a pair of consecutive transitions labeled by `in` and
/// `out`, and turn the mealy machine into a game (what we call a /// `out`, and turn the mealy machine into a game (what we call a
/// split mealy machine) /// split mealy machine)
@ -197,7 +197,7 @@ namespace spot
/// \pre The machines have to be both either split or unsplit, /// \pre The machines have to be both either split or unsplit,
/// input complete and compatible. All of this is checked by assertion. /// input complete and compatible. All of this is checked by assertion.
/// \result A mealy machine representing the shared behaviour, /// \result A mealy machine representing the shared behaviour,
/// with the same tyoe (mealy/separated/split) as the input machines /// with the same type (mealy/separated/split) as the input machines
SPOT_API twa_graph_ptr SPOT_API twa_graph_ptr
mealy_product(const const_twa_graph_ptr& left, mealy_product(const const_twa_graph_ptr& left,
const const_twa_graph_ptr& right); const const_twa_graph_ptr& right);

2
spot/twaalgos/minimize.hh
View file

@ -95,7 +95,7 @@ namespace spot
/// returned. Otherwise, if \a aut_neg_f was not supplied but \a f /// returned. Otherwise, if \a aut_neg_f was not supplied but \a f
/// was, \a aut_neg_f is built from the negation of \a f. Then we /// was, \a aut_neg_f is built from the negation of \a f. Then we
/// check that <code>product(aut,!minimize(aut_f))</code> and <code> /// check that <code>product(aut,!minimize(aut_f))</code> and <code>
/// product(aut_neg_f,minize(aut))</code> are both empty. If they /// product(aut_neg_f,minimize(aut))</code> are both empty. If they
/// are, the the minimization was sound. (See the paper for full /// are, the the minimization was sound. (See the paper for full
/// details.) /// details.)
/// ///

2
spot/twaalgos/parity.cc
View file

@ -133,7 +133,7 @@ namespace spot
current_odd = current_odd != toggle_style; current_odd = current_odd != toggle_style;
bool change_style = false; bool change_style = false;
auto num_sets = old_num_sets; auto num_sets = old_num_sets;
// If the parity neeeds to be changed, then a new acceptance set is created. // If the parity needs to be changed, then a new acceptance set is created.
// The old acceptance sets are shifted // The old acceptance sets are shifted
if (output_odd != current_odd) if (output_odd != current_odd)
{ {

2
spot/twaalgos/parity.hh
View file

@ -166,7 +166,7 @@ namespace spot
/// When \a layered is true all transition that belong to the same /// When \a layered is true all transition that belong to the same
/// layer receive the same color. When layer is `false`, only the /// layer receive the same color. When layer is `false`, only the
/// transition that where used initially to define the layers (i.e, /// transition that where used initially to define the layers (i.e,
/// the transition with the maximal color in the previous exemple), /// the transition with the maximal color in the previous example),
/// get their color adjusted. The other will receive either no /// get their color adjusted. The other will receive either no
/// color (if \a colored is false), or a useless color (if \a colored /// color (if \a colored is false), or a useless color (if \a colored
/// is true). Here "useless color" means the smallest color /// is true). Here "useless color" means the smallest color

2
spot/twaalgos/postproc.cc
View file

@ -365,7 +365,7 @@ namespace spot
// However (1) degeneralization is faster if the input is // However (1) degeneralization is faster if the input is
// GBA, and (2) if we want a deterministic parity automaton and the // GBA, and (2) if we want a deterministic parity automaton and the
// input is not deterministic, that is useless here. We need // input is not deterministic, that is useless here. We need
// to determinize it first, and our deterministization // to determinize it first, and our determinization
// function only deal with TGBA as input. // function only deal with TGBA as input.
if ((via_gba || (want_parity && !a->acc().is_parity())) if ((via_gba || (want_parity && !a->acc().is_parity()))
&& !a->acc().is_generalized_buchi()) && !a->acc().is_generalized_buchi())

8
spot/twaalgos/product.hh
View file

@ -38,7 +38,7 @@ namespace spot
/// conjunction of the acceptance conditions of the two input /// conjunction of the acceptance conditions of the two input
/// automata. /// automata.
/// ///
/// As an optionmization, in case one of the left or right automaton /// As an optimization, in case one of the left or right automaton
/// is weak, the acceptance condition of the result is made simpler: /// is weak, the acceptance condition of the result is made simpler:
/// it usually is the acceptance condition of the other argument, /// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets. /// therefore avoiding the need to introduce new accepting sets.
@ -69,7 +69,7 @@ namespace spot
/// conjunction of the acceptance conditions of the two input /// conjunction of the acceptance conditions of the two input
/// automata. /// automata.
/// ///
/// As an optionmization, in case one of the left or right automaton /// As an optimization, in case one of the left or right automaton
/// is weak, the acceptance condition of the result is made simpler: /// is weak, the acceptance condition of the result is made simpler:
/// it usually is the acceptance condition of the other argument, /// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets. /// therefore avoiding the need to introduce new accepting sets.
@ -98,7 +98,7 @@ namespace spot
/// disjunction of the acceptance conditions of the two input /// disjunction of the acceptance conditions of the two input
/// automata. /// automata.
/// ///
/// As an optionmization, in case one of the left or right automaton /// As an optimization, in case one of the left or right automaton
/// is weak, the acceptance condition of the result is made simpler: /// is weak, the acceptance condition of the result is made simpler:
/// it usually is the acceptance condition of the other argument, /// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets. /// therefore avoiding the need to introduce new accepting sets.
@ -126,7 +126,7 @@ namespace spot
/// disjunction of the acceptance conditions of the two input /// disjunction of the acceptance conditions of the two input
/// automata. /// automata.
/// ///
/// As an optionmization, in case one of the left or right automaton /// As an optimization, in case one of the left or right automaton
/// is weak, the acceptance condition of the result is made simpler: /// is weak, the acceptance condition of the result is made simpler:
/// it usually is the acceptance condition of the other argument, /// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets. /// therefore avoiding the need to introduce new accepting sets.

4
spot/twaalgos/reachiter.hh
View file

@ -73,7 +73,7 @@ namespace spot
/// \param in The source state number. /// \param in The source state number.
/// \param out_s The destination state /// \param out_s The destination state
/// \param out The destination state number. /// \param out The destination state number.
/// \param si The spot::twa_succ_iterator positionned on the current /// \param si The spot::twa_succ_iterator positioned on the current
/// transition. /// transition.
/// ///
/// The in_s and out_s states are owned by the /// The in_s and out_s states are owned by the
@ -141,7 +141,7 @@ namespace spot
/// \param in The source state number. /// \param in The source state number.
/// \param out_s The destination state /// \param out_s The destination state
/// \param out The destination state number. /// \param out The destination state number.
/// \param si The spot::twa_succ_iterator positionned on the current /// \param si The spot::twa_succ_iterator positioned on the current
/// transition. /// transition.
/// ///
/// The in_s and out_s states are owned by the /// The in_s and out_s states are owned by the

6
spot/twaalgos/relabel.cc
View file

@ -137,7 +137,7 @@ namespace spot
}; };
// When split we need to distiguish effectively new and old edges // When split we need to distinguish effectively new and old edges
if (split) if (split)
{ {
aut.get_graph().remove_dead_edges_(); aut.get_graph().remove_dead_edges_();
@ -381,12 +381,12 @@ namespace spot
} }
// Save the composed letters? With a special seperator like T/F? // Save the composed letters? With a special separator like T/F?
// Is swapping between formula <-> bdd expensive // Is swapping between formula <-> bdd expensive
for (auto& e : aut.edges()) for (auto& e : aut.edges())
translate(e.cond); translate(e.cond);
// Remove the new auxilliary variables from the aut // Remove the new auxiliary variables from the aut
bdd c_supp = new_var_supp; bdd c_supp = new_var_supp;
while (c_supp != bddtrue) while (c_supp != bddtrue)
{ {

6
spot/twaalgos/remfin.cc
View file

@ -176,7 +176,7 @@ namespace spot
// Specialized conversion from transition based Rabin acceptance to // Specialized conversion from transition based Rabin acceptance to
// transition based Büchi acceptance. // transition based Büchi acceptance.
// Is able to detect SCCs that are TBA-type (i.e., they can be // Is able to detect SCCs that are TBA-type (i.e., they can be
// converted to Büchi acceptance without chaning their structure). // converted to Büchi acceptance without changing their structure).
// //
// See "Deterministic ω-automata vis-a-vis Deterministic Büchi // See "Deterministic ω-automata vis-a-vis Deterministic Büchi
// Automata", S. Krishnan, A. Puri, and R. Brayton (ISAAC'94) for // Automata", S. Krishnan, A. Puri, and R. Brayton (ISAAC'94) for
@ -381,7 +381,7 @@ namespace spot
{ {
true, // state based true, // state based
true, // inherently weak true, // inherently weak
true, true, // determinisitic true, true, // deterministic
true, // complete true, // complete
true, // stutter inv. true, // stutter inv.
}); });
@ -667,7 +667,7 @@ namespace spot
<< main_add << '\n'; << main_add << '\n';
// If the SCC is rejecting, there is no need for clone. // If the SCC is rejecting, there is no need for clone.
// Pretend we don't interesect any Fin. // Pretend we don't intersect any Fin.
if (si.is_rejecting_scc(n)) if (si.is_rejecting_scc(n))
intersects_fin = false; intersects_fin = false;

2
spot/twaalgos/remfin.hh
View file

@ -23,7 +23,7 @@
namespace spot namespace spot
{ {
/// \ingroup twa_acc_transform /// \ingroup twa_acc_transform
/// \brief Check if \a aut is Rablin-like and Büchi-realizable. /// \brief Check if \a aut is Rabin-like and Büchi-realizable.
/// ///
/// This is inspired from rabin_to_buchi_maybe()'s algorithm. The /// This is inspired from rabin_to_buchi_maybe()'s algorithm. The
/// main difference is that here, no automaton is built. /// main difference is that here, no automaton is built.

2
spot/twaalgos/sccfilter.cc
View file

@ -231,7 +231,7 @@ namespace spot
// all acceptance sets, as this edge cannot be part // all acceptance sets, as this edge cannot be part
// of any loop. // of any loop.
// - If an edge is in an non-accepting SCC, we can only // - If an edge is in an non-accepting SCC, we can only
// remove the Inf sets, as removinf the Fin sets // remove the Inf sets, as removing the Fin sets
// might make the SCC accepting. // might make the SCC accepting.
// //
// The above rules are made more complex with two flags: // The above rules are made more complex with two flags:

6
spot/twaalgos/sccinfo.hh
View file

@ -319,7 +319,7 @@ namespace spot
/// \brief True if we know that the SCC has an accepting cycle /// \brief True if we know that the SCC has an accepting cycle
/// ///
/// Note that both is_accepting() and is_rejecting() may return /// Note that both is_accepting() and is_rejecting() may return
/// false if an SCC interesects a mix of Fin and Inf sets. /// false if an SCC intersects a mix of Fin and Inf sets.
/// Call determine_unknown_acceptance() to decide. /// Call determine_unknown_acceptance() to decide.
bool is_accepting() const bool is_accepting() const
{ {
@ -329,7 +329,7 @@ namespace spot
/// \brief True if we know that all cycles in the SCC are rejecting /// \brief True if we know that all cycles in the SCC are rejecting
/// ///
/// Note that both is_accepting() and is_rejecting() may return /// Note that both is_accepting() and is_rejecting() may return
/// false if an SCC interesects a mix of Fin and Inf sets. /// false if an SCC intersects a mix of Fin and Inf sets.
/// Call determine_unknown_acceptance() to decide. /// Call determine_unknown_acceptance() to decide.
bool is_rejecting() const bool is_rejecting() const
{ {
@ -509,7 +509,7 @@ namespace spot
scc_info(const scc_and_mark_filter& filt, scc_info_options options); scc_info(const scc_and_mark_filter& filt, scc_info_options options);
// we separate the two functions so that we can rename // we separate the two functions so that we can rename
// scc_info(x,options) into scc_info_with_options(x,options) in Python. // scc_info(x,options) into scc_info_with_options(x,options) in Python.
// Otherwrise calling scc_info(aut,options) can be confused with // Otherwise calling scc_info(aut,options) can be confused with
// scc_info(aut,initial_state). // scc_info(aut,initial_state).
scc_info(const scc_and_mark_filter& filt) scc_info(const scc_and_mark_filter& filt)
: scc_info(filt, scc_info_options::ALL) : scc_info(filt, scc_info_options::ALL)

4
spot/twaalgos/se05.cc
View file

@ -215,7 +215,7 @@ namespace spot
// the test 'c.get_color() != RED' is added to limit // the test 'c.get_color() != RED' is added to limit
// the number of runs reported by successive // the number of runs reported by successive
// calls to the check method. Without this // calls to the check method. Without this
// functionnality, the test can be ommited. // functionality, the test can be omitted.
trace << " It is cyan or blue and the arc is " trace << " It is cyan or blue and the arc is "
<< "accepting, start a red dfs" << std::endl; << "accepting, start a red dfs" << std::endl;
c.set_color(RED); c.set_color(RED);
@ -244,7 +244,7 @@ namespace spot
// the test 'c.get_color() != RED' is added to limit // the test 'c.get_color() != RED' is added to limit
// the number of runs reported by successive // the number of runs reported by successive
// calls to the check method. Without this // calls to the check method. Without this
// functionnality, the test can be ommited. // functionality, the test can be omitted.
trace << " The arc from " trace << " The arc from "
<< a_->format_state(st_blue.front().s) << a_->format_state(st_blue.front().s)
<< " to the current state is accepting, start a " << " to the current state is accepting, start a "

6
spot/twaalgos/se05.hh
View file

@ -33,7 +33,7 @@ namespace spot
/// \pre The automaton \a a must have at most one acceptance condition (i.e. /// \pre The automaton \a a must have at most one acceptance condition (i.e.
/// it is a TBA). /// it is a TBA).
/// ///
/// During the visit of \a a, the returned checker stores explicitely all /// During the visit of \a a, the returned checker stores explicitly all
/// the traversed states. /// the traversed states.
/// The method \a check() of the checker can be called several times /// The method \a check() of the checker can be called several times
/// (until it returns a null pointer) to enumerate all the visited accepting /// (until it returns a null pointer) to enumerate all the visited accepting
@ -92,11 +92,11 @@ namespace spot
/// \pre The automaton \a a must have at most one acceptance condition (i.e. /// \pre The automaton \a a must have at most one acceptance condition (i.e.
/// it is a TBA). /// it is a TBA).
/// ///
/// During the visit of \a a, the returned checker does not store explicitely /// During the visit of \a a, the returned checker does not store explicitly
/// the traversed states but uses the bit-state hashing technic presented in /// the traversed states but uses the bit-state hashing technic presented in
/// \cite holzmann.91.book /// \cite holzmann.91.book
/// ///
/// Consequently, the detection of an acceptence cycle is not ensured. /// Consequently, the detection of an acceptance cycle is not ensured.
/// ///
/// The size of the heap is limited to \n size bytes. /// The size of the heap is limited to \n size bytes.
/// ///

8
spot/twaalgos/simulation.hh
View file

@ -51,7 +51,7 @@ namespace spot
/// The resulting automaton has a named property "simulated-states", /// The resulting automaton has a named property "simulated-states",
/// that is a vector mapping each state of the input to a state of /// that is a vector mapping each state of the input to a state of
/// the output. Note that some input states may be mapped to -1, as /// the output. Note that some input states may be mapped to -1, as
/// a by-product of transition prunning. /// a by-product of transition pruning.
/// ///
/// \param automaton the automaton to simulate. /// \param automaton the automaton to simulate.
/// ///
@ -153,7 +153,7 @@ namespace spot
/// then reduce the automaton. /// then reduce the automaton.
/// ///
/// There is no need to call scc_filter() before as it is always applied to /// There is no need to call scc_filter() before as it is always applied to
/// remove dead and unreacheable states. /// remove dead and unreachable states.
/// ///
/// \param aut the automaton to simulate. /// \param aut the automaton to simulate.
/// \return a new automaton which is at worst a copy of the received /// \return a new automaton which is at worst a copy of the received
@ -171,7 +171,7 @@ namespace spot
/// way as reduce_direct_sim(). /// way as reduce_direct_sim().
/// ///
/// There is no need to call scc_filter() before as it is always applied to /// There is no need to call scc_filter() before as it is always applied to
/// remove dead and unreacheable states. /// remove dead and unreachable states.
/// ///
/// \param aut the automaton to simulate. /// \param aut the automaton to simulate.
/// \return a new automaton which is at worst a copy of the received /// \return a new automaton which is at worst a copy of the received
@ -190,7 +190,7 @@ namespace spot
/// transitions). /// transitions).
/// ///
/// There is no need to call scc_filter() before as it is always applied to /// There is no need to call scc_filter() before as it is always applied to
/// remove dead and unreacheable states. /// remove dead and unreachable states.
/// ///
/// \param aut the automaton to simulate. /// \param aut the automaton to simulate.
/// \return a new automaton which is at worst a copy of the received /// \return a new automaton which is at worst a copy of the received

2
spot/twaalgos/split.hh
View file

@ -234,6 +234,6 @@ namespace spot
/// ///
/// Using split_edges() also creates an automaton with separated labels, /// Using split_edges() also creates an automaton with separated labels,
/// but the separation will be much finer since it will result in a much /// but the separation will be much finer since it will result in a much
/// involves all atomtic proposition. /// involves all atomic proposition.
SPOT_API twa_graph_ptr separate_edges(const const_twa_graph_ptr& aut); SPOT_API twa_graph_ptr separate_edges(const const_twa_graph_ptr& aut);
} }

2
spot/twaalgos/stats.hh
View file

@ -51,7 +51,7 @@ namespace spot
/// \brief Compute sub statistics for an automaton. /// \brief Compute sub statistics for an automaton.
SPOT_API twa_sub_statistics sub_stats_reachable(const const_twa_ptr& g); SPOT_API twa_sub_statistics sub_stats_reachable(const const_twa_ptr& g);
/// \brief Count all transtitions, even unreachable ones. /// \brief Count all transitions, even unreachable ones.
SPOT_API unsigned long long SPOT_API unsigned long long
count_all_transitions(const const_twa_graph_ptr& g); count_all_transitions(const const_twa_graph_ptr& g);

2
spot/twaalgos/synthesis.cc
View file

@ -1418,7 +1418,7 @@ namespace spot
auto delta = sw.stop(); auto delta = sw.stop();
bv->trans_time += delta; bv->trans_time += delta;
if (vs) if (vs)
*vs << "tanslating formula done in " << delta << " seconds\n"; *vs << "translating formula done in " << delta << " seconds\n";
} }
res->prop_complete(trival::maybe()); res->prop_complete(trival::maybe());

2
spot/twaalgos/synthesis.hh
View file

@ -209,7 +209,7 @@ namespace spot
}; };
/// \ingroup synthesis /// \ingroup synthesis
/// \brief Seeks to decompose a formula into independently synthesizable /// \brief Seeks to decompose a formula into independently synthetizable
/// sub-parts. The conjunction of all sub-parts then /// sub-parts. The conjunction of all sub-parts then
/// satisfies the specification /// satisfies the specification
/// ///

2
spot/twaalgos/tau03.hh
View file

@ -31,7 +31,7 @@ namespace spot
/// ///
/// \pre The automaton \a a must have at least one acceptance condition. /// \pre The automaton \a a must have at least one acceptance condition.
/// ///
/// During the visit of \a a, the returned checker stores explicitely all /// During the visit of \a a, the returned checker stores explicitly all
/// the traversed states. The implemented algorithm is the following: /// the traversed states. The implemented algorithm is the following:
/// ///
/** \verbatim /** \verbatim

4
spot/twaalgos/tau03opt.hh
View file

@ -31,7 +31,7 @@ namespace spot
/// ///
/// \pre The automaton \a a must have at least one acceptance condition. /// \pre The automaton \a a must have at least one acceptance condition.
/// ///
/// During the visit of \a a, the returned checker stores explicitely all /// During the visit of \a a, the returned checker stores explicitly all
/// the traversed states. The implemented algorithm is the following: /// the traversed states. The implemented algorithm is the following:
/// ///
/** \verbatim /** \verbatim
@ -84,7 +84,7 @@ namespace spot
end; end;
\endverbatim */ \endverbatim */
/// ///
/// This algorithm is a generalisation to TGBA of the one implemented in /// This algorithm is a generalization to TGBA of the one implemented in
/// spot::explicit_se05_search. It is based on the acceptance set labelling /// spot::explicit_se05_search. It is based on the acceptance set labelling
/// of states used in spot::explicit_tau03_search. Moreover, it introduce /// of states used in spot::explicit_tau03_search. Moreover, it introduce
/// a slight optimisation based on vectors of integers counting for each /// a slight optimisation based on vectors of integers counting for each

6
spot/twaalgos/toparity.hh
View file

@ -135,7 +135,7 @@ namespace spot
/// This procedure combines many strategies in an attempt to produce /// This procedure combines many strategies in an attempt to produce
/// the smallest possible parity automaton. Some of the strategies /// the smallest possible parity automaton. Some of the strategies
/// include CAR (color acceptance record), IAR (index appearance /// include CAR (color acceptance record), IAR (index appearance
/// record), partial degenerazation, conversion from Rabin to Büchi /// record), partial degeneralization, conversion from Rabin to Büchi
/// when possible, etc. /// when possible, etc.
/// ///
/// The \a options argument can be used to selectively disable some of the /// The \a options argument can be used to selectively disable some of the
@ -152,7 +152,7 @@ namespace spot
/// ///
/// This implements a straightforward adaptation of the LAR (latest /// This implements a straightforward adaptation of the LAR (latest
/// appearance record) to automata with transition-based marks. We /// appearance record) to automata with transition-based marks. We
/// call this adaptation the CAR (color apperance record), as it /// call this adaptation the CAR (color appearance record), as it
/// tracks colors (i.e., acceptance sets) instead of states. /// tracks colors (i.e., acceptance sets) instead of states.
/// ///
/// It is better to use to_parity() instead, as it will use better /// It is better to use to_parity() instead, as it will use better
@ -186,7 +186,7 @@ namespace spot
/// \ingroup twa_acc_transform /// \ingroup twa_acc_transform
/// \brief Turn a Rabin-like or Streett-like automaton into a parity automaton /// \brief Turn a Rabin-like or Streett-like automaton into a parity automaton
/// based on the index appearence record (IAR) /// based on the index appearance record (IAR)
/// ///
/// Returns nullptr if the input automaton is neither Rabin-like nor /// Returns nullptr if the input automaton is neither Rabin-like nor
/// Streett-like, and calls spot::iar() otherwise. /// Streett-like, and calls spot::iar() otherwise.

2
spot/twaalgos/totgba.hh
View file

@ -71,7 +71,7 @@ namespace spot
/// \brief Take an automaton with any acceptance condition and return /// \brief Take an automaton with any acceptance condition and return
/// an equivalent Generalized Streett automaton. /// an equivalent Generalized Streett automaton.
/// ///
/// This works by putting the acceptance condition in cunjunctive /// This works by putting the acceptance condition in conjunctive
/// normal form, and then merging all the /// normal form, and then merging all the
/// Inf(x1)|Inf(x2)|...|Inf(xn) that may occur in clauses into a /// Inf(x1)|Inf(x2)|...|Inf(xn) that may occur in clauses into a
/// single Inf(X). /// single Inf(X).

2
spot/twaalgos/translate.hh
View file

@ -36,7 +36,7 @@ namespace spot
/// automaton produced (TGBA, BA, Monitor). The default is TGBA. /// automaton produced (TGBA, BA, Monitor). The default is TGBA.
/// ///
/// Method set_pref() may be used to specify whether small automata /// Method set_pref() may be used to specify whether small automata
/// should be prefered over deterministic automata. /// should be preferred over deterministic automata.
/// ///
/// Method set_level() may be used to specify the optimization level. /// Method set_level() may be used to specify the optimization level.
/// ///

2
spot/twaalgos/word.cc
View file

@ -206,7 +206,7 @@ namespace spot
if (word[ind] == '}') if (word[ind] == '}')
word_parse_error(word, ind, "Expected ';' delimiter: " word_parse_error(word, ind, "Expected ';' delimiter: "
"'}' stands for ending a cycle"); "'}' stands for ending a cycle");
// Exract formula, convert it to bdd and add it to the prefix sequence // Extract formula, convert it to bdd and add it to the prefix sequence
extract_bdd(tw->prefix); extract_bdd(tw->prefix);
if (i == std::string::npos) if (i == std::string::npos)
word_parse_error(word, ind + 1, "Missing cycle in formula"); word_parse_error(word, ind + 1, "Missing cycle in formula");

4
spot/twaalgos/word.hh
View file

@ -39,7 +39,7 @@ namespace spot
dict_->unregister_all_my_variables(this); dict_->unregister_all_my_variables(this);
} }
/// \brief Simplify a lasso-shapped word. /// \brief Simplify a lasso-shaped word.
/// ///
/// The simplified twa_word may represent a subset of the actual /// The simplified twa_word may represent a subset of the actual
/// words represented by the original twa_word. The typical /// words represented by the original twa_word. The typical
@ -79,7 +79,7 @@ namespace spot
/// \brief Convert the twa_word as an automaton. /// \brief Convert the twa_word as an automaton.
/// ///
/// Convert the twa_word into a lasso-shapred automaton /// Convert the twa_word into a lasso-shaped automaton
/// with "true" acceptance condition. /// with "true" acceptance condition.
/// ///
/// This is useful to evaluate a word on an automaton. /// This is useful to evaluate a word on an automaton.

2
spot/twaalgos/zlktree.cc
View file

@ -816,7 +816,7 @@ namespace spot
throw std::runtime_error("acd::first_branch(): unknown state " + throw std::runtime_error("acd::first_branch(): unknown state " +
std::to_string(s)); std::to_string(s));
unsigned scc = si_->scc_of(s); unsigned scc = si_->scc_of(s);
if (trees_[scc].trivial) // the branch is irrelevant for transiant SCCs if (trees_[scc].trivial) // the branch is irrelevant for transient SCCs
return 0; return 0;
if (SPOT_UNLIKELY(nodes_.empty())) if (SPOT_UNLIKELY(nodes_.empty()))
// make sure we do not complain about this if all SCCs are trivial. // make sure we do not complain about this if all SCCs are trivial.

6
spot/twaalgos/zlktree.hh
View file

@ -480,13 +480,13 @@ namespace spot
/// ///
/// If \a colored is set, each output transition will have exactly /// If \a colored is set, each output transition will have exactly
/// one color, and the output automaton will use at most n+1 colors /// one color, and the output automaton will use at most n+1 colors
/// if the input has n colors. If \a colored is unsed (the default), /// if the input has n colors. If \a colored is unset (the default),
/// output transitions will use at most one color, and output /// output transitions will use at most one color, and output
/// automaton will use at most n colors. /// automaton will use at most n colors.
/// ///
/// The acd_tranform() is the original function producing /// The acd_transform() is the original function producing
/// optimal transition-based output (optimal in the sense of least /// optimal transition-based output (optimal in the sense of least
/// number of duplicated states), while the acd_tansform_sbacc() variant /// number of duplicated states), while the acd_transform_sbacc() variant
/// produces state-based output from transition-based input and without /// produces state-based output from transition-based input and without
/// any optimality claim. The \a order_heuristics argument, enabled /// any optimality claim. The \a order_heuristics argument, enabled
/// by default activates the ORDER_HEURISTICS option of the ACD. /// by default activates the ORDER_HEURISTICS option of the ACD.

8
spot/twacube/cube.hh
View file

@ -41,18 +41,18 @@ namespace spot
/// Warning : a variable cannot be set in both bitset at the /// Warning : a variable cannot be set in both bitset at the
/// same time (consistency! cannot be true and false) /// same time (consistency! cannot be true and false)
/// ///
/// The cube for (a & !b) will be repensented by : /// The cube for (a & !b) will be represented by:
/// - true_var = 1 0 /// - true_var = 1 0
/// - false_var = 0 1 /// - false_var = 0 1
/// ///
/// To represent free variables such as in (a & !b) | (a & b) /// To represent free variables such as in (a & !b) | (a & b)
/// (wich is equivalent to (a) with b free) /// (which is equivalent to (a) with b free)
/// - true_var : 1 0 /// - true_var : 1 0
/// - false_var : 0 0 /// - false_var : 0 0
/// This exemple shows that the representation of free variables /// This example shows that the representation of free variables
/// is done by unsetting variable in both vector /// is done by unsetting variable in both vector
/// ///
/// To be memory efficient, these two bitsets are contigous in memory /// To be memory efficient, these two bitsets are contigious in memory
/// i.e. if we want to represent 35 variables, a cube will be /// i.e. if we want to represent 35 variables, a cube will be
/// represented by 4 unsigned int contiguous in memory. The 35 /// represented by 4 unsigned int contiguous in memory. The 35
/// first bits represent truth values. The 29 bits following are /// first bits represent truth values. The 29 bits following are

Some files were not shown because too many files have changed in this diff Show more