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
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.
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_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);

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 "
"force this relabeling to always occur with option --relabel.\n"
"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"
" before outputing it.\n"
" before outputting it.\n"
"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 "
"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,
// 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>>
filter_list_of_aps(const std::unordered_set<std::string>& aps,
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 \
implication checks for formula simplifications. Defaults to 64.") },
{ 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.") },
{ nullptr, 0, nullptr, 0, "Translation options:", 0 },
{ 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.") },
{ nullptr, 0, nullptr, 0, "Postprocessing options:", 0 },
{ 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.") },
{ DOC("scc-filter", "Set to 1 (the default) to enable \
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 \
SCC. Set to 2 to remove even these entering transition from the \
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 \
degeneralization algorithm will reset its level any time it exits \
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 \
for the presence of an accepting self-loop.") },
{ 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.") },
{ DOC("det-max-states", "When defined to a positive integer N, \
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.") },
{ DOC("simul-max", "Number of states above which simulation-based \
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.") },
{ DOC("simul-trans-pruning", "Number of equivalence classes above which \
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",
"Chose which simulation based reduction to use: 1 force the \
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 }
};

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
/// 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
/// check that the automaton generated with AUT_CYCLIST_TRACE_NBA
/// 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
/// 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
/// check that the automaton generated with AUT_CYCLIST_TRACE_NBA
/// 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
/// Edge_Data might be void.
@ -818,7 +818,7 @@ namespace spot
&& (dests_.capacity() - dests_.size()) < (sz + 1))
{
// 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.
std::vector<unsigned> tmp(dst_begin, dst_end);
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)
internal::all_trans<const digraph> edges() const
{

2
spot/ltsmin/ltsmin.hh
View file

@ -73,7 +73,7 @@ namespace spot
int compress = 0) const;
// \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"
ltsmin_kripkecube_ptr kripkecube(std::vector<std::string> to_observe,
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
/// 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.
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
/// 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
{
public:

2
spot/mc/bloemen.hh
View file

@ -63,7 +63,7 @@ namespace spot
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
{
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_;
};
/// \brief The haser for the previous uf_element.
/// \brief The hasher for the previous uf_element.
struct uf_element_hasher
{
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_);
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
// found without launching a red dfs
if (tmp.second.colors->l[tid_].cyan)
@ -499,7 +499,7 @@ namespace spot
}
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_red_; ///< \ brief Red Stack
unsigned transitions_ = 0; ///< \brief Number of transitions
@ -514,7 +514,7 @@ namespace spot
std::atomic<bool>& stop_; ///< \brief Stop-the-world boolean
std::vector<product_state> Rp_; ///< \brief Rp 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;
};
}

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
/// contains a deadlock. This deadlock detection performs a DFS traversal
/// 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.
template<typename State, typename SuccIterator,
typename StateHash, typename StateEqual,
@ -59,7 +59,7 @@ namespace spot
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
{
pair_hasher(const deadlock_pair*)
@ -298,7 +298,7 @@ namespace spot
bool deadlock_ = false; ///< \brief Deadlock detected?
std::atomic<bool>& stop_; ///< \brief Stop-the-world boolean
/// \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_;
bool finisher_ = false;
};

4
spot/mc/intersect.hh
View file

@ -25,9 +25,9 @@
namespace spot
{
/// \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
/// 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.
template<typename SuccIterator, typename State>
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
/// 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
/// 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
/// values.
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
/// a given parameter can be compsidered as a modelchecking algorithm
/// (i.e., usable by instanciate)
/// a given parameter can be considered as a modelchecking algorithm
/// (i.e., usable by instantiate)
template <typename T>
class SPOT_API is_a_mc_algorithm
{
@ -123,7 +123,7 @@ namespace spot
}
#endif
// Wait all threads to be instanciated.
// Wait all threads to be instantiated.
while (barrier)
continue;
swarmed[i]->run();
@ -169,8 +169,8 @@ namespace spot
bool go_on = true;
for (unsigned i = 0; i < nbth && go_on; ++i)
{
// Enumerate cases where a trace can be extraced
// Here we use a switch so that adding new algortihm
// Enumerate cases where a trace can be extracted
// Here we use a switch so that adding new algorithm
// with new return status will trigger an error that
// should the be fixed here.
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
// accept any parenthesized block as an atomic propoistion.
// accept any parenthesized block as an atomic proposition.
bool is_spin_ap(const char* 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
/// is deallocated one at a time
/// - 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
/// ressource. In this case it's hard to detect wich pool has allocated
/// some ressource.
/// resource. In this case it's hard to detect which pool has allocated
/// some resource.
enum class pool_type { Safe , Unsafe };
/// 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
/// be 256 wide.

6
spot/misc/minato.hh
View file

@ -33,14 +33,14 @@ namespace spot
class SPOT_API minato_isop
{
public:
/// \brief Conctructor.
/// \brief Constructor.
/// \arg input The BDD function to translate in ISOP.
minato_isop(bdd input);
/// \brief Conctructor.
/// \brief Constructor.
/// \arg input The BDD function to translate in ISOP.
/// \arg vars The set of BDD variables to factorize in \a input.
minato_isop(bdd input, bdd vars);
/// \brief Conctructor.
/// \brief Constructor.
///
/// This version allow some flexibility in computing the ISOP.
/// 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
{
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
/// distributed version of PicoSAT will be used.
satsolver();
@ -116,7 +116,7 @@ namespace spot
template<typename T, typename... Args>
void comment(T first, Args... args);
/// \brief Assume a litteral value.
/// \brief Assume a literal value.
/// Must only be used with distributed picolib.
void assume(int lit);
@ -159,7 +159,7 @@ namespace spot
int nassumptions_vars_; // Surplus of vars (for 'assume' algorithm).
/// \brief Number of solutions to obtain from the satsolver
/// (without assuming litterals).
/// (without assuming literals).
int nsols_;
/// \brief Picosat satsolver instance.

2
spot/misc/timer.hh
View file

@ -147,7 +147,7 @@ namespace spot
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.
///
/// 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.
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;
/// Location of the automaton in the stream.
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
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
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,
bool dtbasat);
/// \brief Compute min_t litteral as well as min_ta, min_p and max_p.
/// After this step, all litterals are known.
/// \brief Compute min_t literal as well as min_ta, min_p and max_p.
/// After this step, all literals are known.
void
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
get_t(unsigned src, unsigned cond, unsigned dst) const
{
@ -134,12 +134,12 @@ public:
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
/// 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
/// litteral for each src.
/// literal for each src.
inline int
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;
}
/// \brief Return the path's litteral corresponding to parameters.
/// \brief Return the path's literal corresponding to parameters.
inline int
get_p(unsigned path, unsigned src, unsigned dst) const
{
@ -181,9 +181,9 @@ public:
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
/// litteral. false -> ref | true -> cand
/// literal. false -> ref | true -> cand
inline int
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,
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
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.
///
/// 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.
///
virtual ta_succ_iterator*
@ -121,7 +121,7 @@ namespace spot
/// filtred by the changeset on transitions
///
/// 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.
///
virtual ta_succ_iterator*
@ -142,7 +142,7 @@ namespace spot
/// \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.
virtual std::string
format_state(const spot::state* s) const = 0;
@ -190,7 +190,7 @@ namespace spot
///
/// This class provides the basic functionalities required to
/// 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
/// be queried while iterating over the successors.
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 filtred by condition
// return transitions filtered by condition
state_ta_explicit::transitions*
state_ta_explicit::get_transitions(bdd condition) const
{
@ -279,7 +279,7 @@ namespace spot
bool dest_is_livelock_accepting =
dest->is_livelock_accepting_state();
//Before deleting stuttering transitions, propaged back livelock
//Before deleting stuttering transitions, propagated back livelock
//and initial state's properties
if (is_stuttering_transition)
{

2
spot/ta/taproduct.hh
View file

@ -158,7 +158,7 @@ namespace spot
virtual bool
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)
bool
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.
//
// 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
// License for more deta_explicitils.
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
@ -74,7 +74,7 @@ namespace spot
/// \a state and his successors
///
/// 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.
///
virtual twa_succ_iterator*

2
spot/taalgos/reachiter.hh
View file

@ -78,7 +78,7 @@ namespace spot
///
/// \param in The source 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.
virtual void
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
/// form of TA, called GTA (Generalized Testing Automaton).
/// 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
/// 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

2
spot/tl/apcollect.cc
View file

@ -69,7 +69,7 @@ namespace spot
{
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)
{
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);
/// \brief Collect the literals occuring in f
/// \brief Collect the literals occurring in f
///
/// This function records each atomic proposition occurring in f
/// 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.
//
// 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(),
[o](const fnode* f) { return f == nullptr || f->is(o); })
!= 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
/// value even if it encountered error during the parsing of \a
/// 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.
SPOT_API
@ -133,7 +133,7 @@ namespace spot
/// field parsed_formula::f in the returned object can be a non-zero
/// value even if it encountered error during the parsing of \a
/// 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.
SPOT_API
@ -154,7 +154,7 @@ namespace spot
/// field parsed_formula::f in the returned object can be a non-zero
/// value even if it encountered error during the parsing of \a
/// 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
/// 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
/// value even if it encountered error during the parsing of \a
/// 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.
SPOT_API

2
spot/tl/randomltl.hh
View file

@ -200,7 +200,7 @@ namespace spot
class SPOT_API random_sere final: public random_formula
{
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:
///

2
spot/tl/relabel.hh
View file

@ -35,7 +35,7 @@ namespace spot
/// between the new names (keys) and the old names (values).
///
/// \see relabel_bse
/// \see relabel_overlaping_bse
/// \see relabel_overlapping_bse
SPOT_API
formula relabel(formula f, relabeling_style style,
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))).
formula
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
// 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.
if (opt_.favor_event_univ)
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))
if (!opt_.reduce_size_strictly)
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
///
/// \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.
bdd to_bdd(const bdd* map) const;
@ -1275,7 +1275,7 @@ namespace spot
/// Fin(i) changed to true and Inf(i) to false.
///
/// 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.
///
/// 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
/// searched in the formula, and the output (i, left, right).
/// 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.
/// @{
std::tuple<int, acc_cond::acc_code, acc_cond::acc_code>
@ -1345,7 +1345,7 @@ namespace spot
/// \brief Check potential acceptance of an SCC.
///
/// 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
/// included in all sets in \a always_present (i.e., all
/// 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.
///
/// 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.).
///
/// 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.
///
/// 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.
///
/// 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
/// searched in the formula, and the output (i, left, right).
/// 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.
/// @{
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.
/// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
/// \return The BDD formatted as a string.
SPOT_API std::string
bdd_format_sat(const bdd_dict_ptr& dict, bdd b);
@ -50,7 +50,7 @@ namespace spot
/// \param os The output stream.
/// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
/// \return The BDD formatted as a string.
SPOT_API std::ostream&
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.
/// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
/// \return The BDD formatted as a string.
SPOT_API std::string
bdd_format_accset(const bdd_dict_ptr& dict, bdd b);
@ -73,7 +73,7 @@ namespace spot
/// \brief Format a BDD as a set.
/// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
/// \return The BDD formatted as a string.
SPOT_API std::string
bdd_format_set(const bdd_dict_ptr& dict, bdd b);
@ -87,7 +87,7 @@ namespace spot
/// \brief Format a BDD as a formula.
/// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
/// \return The BDD formatted as a string.
SPOT_API std::string
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.
/// \param dict The dictionary to use, to lookup variables.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
/// \return The BDD formatted as a string.
SPOT_API std::string
bdd_format_isop(const bdd_dict_ptr& dict, bdd b);

2
spot/twa/formula2bdd.cc
View file

@ -25,7 +25,7 @@ namespace spot
{
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
// exchange ∧ and ∨.
template<bool dual>

8
spot/twa/twa.hh
View file

@ -630,14 +630,14 @@ namespace spot
/// \brief Get the initial state of the automaton.
///
/// 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.
virtual const state* get_init_state() const = 0;
/// \brief Get an iterator over the successors of \a local_state.
///
/// 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.
///
/// \see succ()
@ -785,7 +785,7 @@ namespace spot
/// \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
/// small objects, maybe sharing data with other state objects via
/// data structure stored in the automaton.
@ -795,7 +795,7 @@ namespace spot
///
/// This converts \a s, into that corresponding spot::state for \a
/// 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.
///
/// 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.)
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
// state (by default its own number) or some common value if the
// state contains self-loop.
@ -505,7 +505,7 @@ namespace spot
}
// All states that might possible be merged share the same hash
// Info hash coll
//std::cout << "Hash collission rate pre merge: "
//std::cout << "Hash collision rate pre merge: "
// << ((map0.size()+map1.size())/((float)n_states))
// << '\n';
@ -561,7 +561,7 @@ namespace spot
sl1 = e_chain[sl1];
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.
else if (edge_data_comp(data1, data2))
sl1 = e_chain[sl1];
@ -747,7 +747,7 @@ namespace spot
if (merged)
defrag_states(remap, st);
// 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()))
// << '\n';
return merged;

2
spot/twa/twagraph.hh
View file

@ -600,7 +600,7 @@ namespace spot
/// the edges
/// \param to_merge_ptr Determines which states are candidates.
/// 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
/// more states are merged.
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.second.id()); });
if (itm == occur_map.cend())
throw std::runtime_error("Empty occurence map");
throw std::runtime_error("Empty occurrence map");
return *itm;
};
@ -1180,7 +1180,7 @@ namespace spot
// Create all the bdds/vars
// 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
{
v = circ.aig_pos(v);

4
spot/twaalgos/aiger.hh
View file

@ -86,7 +86,7 @@ namespace spot
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.
/// 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,
/// 1: isop normal form, 2: try both and retain smaller
/// \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
/// 1: Separate the different types of input signals
/// (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
/// (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).
class SPOT_API outedge_combiner
{

2
spot/twaalgos/cleanacc.cc
View file

@ -549,7 +549,7 @@ namespace spot
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.
if (e.acc == previous_a)
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:
// bv1 -> the set of original states that it represents
// 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.
dca_st_mapping bv_to_num_;
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)
{
// The first containement check does not involve a
// The first containment check does not involve a
// complementation, the second might.
return contains(left, right) && contains(right, left);
}
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.
return contains(right, left) && contains(left, right);
}

4
spot/twaalgos/couvreurnew.cc
View file

@ -282,7 +282,7 @@ namespace spot
const_twa_ptr>::type;
// 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,
// and the heap of visited states with their indices.
template<bool is_explicit>
@ -579,7 +579,7 @@ namespace spot
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
// emptiness_check_result should not be exposed.
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
/// 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
/// cycle.
///

6
spot/twaalgos/degen.cc
View file

@ -32,7 +32,7 @@ namespace spot
{
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 list of acceptance sets.
typedef std::pair<unsigned, unsigned> degen_state;
@ -495,7 +495,7 @@ namespace spot
levels->emplace_back(ds.second);
// 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
// re-entering the SCC.
if (use_lvl_cache)
@ -579,7 +579,7 @@ namespace spot
// where 1 is initial and => marks accepting
// edges: 1=>1, 1=>2, 2->2, 2->1. This is
// 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
// 2, depending on whether we reach it using 1=>2
// 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
/// 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
/// will builds a state-based (co)Büchi automaton that has at most
/// (N+1) times the number of states of the original automaton.
@ -38,12 +38,12 @@ namespace spot
///
/// Additional options control optimizations described in
/// \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
/// compute a custom acceptance order for each SCC (this option is
/// disabled by default because our benchmarks show that it usually
/// 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
/// 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
@ -75,7 +75,7 @@ namespace spot
///
/// As an alternative method to degeneralization, one may also
/// 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
/// degeneralize() on the average. See \cite casares.22.tacas for
/// some comparisons.

2
spot/twaalgos/dot.hh
View file

@ -29,7 +29,7 @@ namespace spot
/// \brief Print reachable states in dot format.
///
/// 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
/// 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.
//
// 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.
unsigned path_size = 0;
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
// corresponding index in alpha_map. This is necessary beacause
// Fill dict's bdd vector (alpha_vect) and save each bdd and it's
// corresponding index in alpha_map. This is necessary because
// some loops start from a precise bdd. Therefore, it's useful
// to know its corresponding index to deal with vars_helper.
unsigned j = 0;
@ -281,7 +281,7 @@ namespace spot
d.helper.init(d.cand_size, d.alpha_vect.size(), d.cand_size,
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);
}
@ -399,7 +399,7 @@ namespace spot
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,
// must also be marked as not accepting in the cand. automaton
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
// also be marked as accepting in the candidate.
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,
// an ID number.
//
// Given this ID, src_cand, dst_cand, the corresponding litteral can be
// retrived thanks to get_prc(...) a vars_helper's method.
// Given this ID, src_cand, dst_cand, the corresponding literal can be
// retrieved thanks to get_prc(...) a vars_helper's method.
unsigned path_size = 0;
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
// corresponding index in alpha_map. This is necessary beacause
// Fill dict's bdd vector (alpha_vect) and save each bdd and it's
// corresponding index in alpha_map. This is necessary because
// some loops start from a precise bdd. Therefore, it's useful
// to know its corresponding index to deal with vars_helper.
unsigned j = 0;
@ -510,7 +510,7 @@ namespace spot
d.helper.init(d.cand_size, d.alpha_vect.size(), d.cand_size,
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);
}
@ -909,7 +909,7 @@ namespace spot
dout << "--- transition_acc variables ---\n";
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";
for (unsigned i = 0; i < satdict.cand_size; ++i)
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.
///
/// 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
/// state as many time as param value.
/// 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
// another approach that should be exponential in the
// 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 the options parametrizing how the accepting run is computed.
// / Return the options parameterizing how the accepting run is computed.
const option_map&
options() const
{
@ -153,7 +153,7 @@ namespace spot
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&
options() const
{

2
spot/twaalgos/emptiness_stats.hh
View file

@ -127,7 +127,7 @@ namespace spot
}
private :
unsigned states_; /// number of disctint visited states
unsigned states_; /// number of distinct visited states
unsigned transitions_; /// number of visited transitions
unsigned 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)
{
// 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
// subgame given as rd.
// If acc_par is true, max_par transitions are also accepting and
@ -860,7 +860,7 @@ namespace spot
// during construction
std::vector<strat_t> s_;
// Informations about sccs andthe current scc
// Informations about sccs and the current scc
std::unique_ptr<scc_info> info_;
par_t max_abs_par_; // Max parity occurring in the current scc
// Minimal and maximal parity occurring in the entire graph
@ -1112,7 +1112,7 @@ namespace spot
if (owners->size() != arena->num_states())
throw std::runtime_error("set_state_player(): The \"state-player\" "
"vector has a different "
"size comparerd to the automaton! "
"size compared to the automaton! "
"Called new_state in between?");
(*owners)[state] = owner;
@ -1286,7 +1286,7 @@ namespace spot
game->set_named_prop("strategy", strategy);
// 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 {
unsigned edgeidx;
};

2
spot/twaalgos/genem.hh
View file

@ -114,7 +114,7 @@ namespace spot
/// Give the set of transitions contained in
/// 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 aut_acc Acceptance condition used for this SCC
/// \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.
///
/// 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
/// aliases are defined.
///

4
spot/twaalgos/langmap.hh
View file

@ -26,8 +26,8 @@ namespace spot
/// \brief Identify states that recognize the same language.
///
/// 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
/// total number of recognized languages, states recognizing the same
// / The number of different values (ignoring occurrences) in the vector is
/// the total number of recognized languages, states recognizing the same
/// language have the same value.
///
/// 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.
/// 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 .
///
/// \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 number of runs reported by successive
// 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 "
<< "accepting, start a red dfs" << std::endl;
target = f.s;
@ -242,7 +242,7 @@ namespace spot
// the test 'c.get_color() != RED' is added to limit
// the number of runs reported by successive
// 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 "
<< a_->format_state(st_blue.front().s)
<< " 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.
/// 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 method \a check() of the checker can be called several times
/// (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.
/// 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:
/// \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.
///

4
spot/twaalgos/mask.hh
View file

@ -136,7 +136,7 @@ namespace spot
/// </code>
/// It can modify either the condition or the acceptance sets of
/// 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.
template<typename Trans>
void transform_copy(const const_twa_graph_ptr& old,
@ -157,7 +157,7 @@ namespace spot
acc_cond::mark_t acc = t.acc;
trans(t.src, cond, acc, t.dst);
// 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());
if (cond != bddfalse)
cpy->new_edge(t.src, t.dst, cond, acc);

4
spot/twaalgos/mealy_machine.cc
View file

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

4
spot/twaalgos/mealy_machine.hh
View file

@ -91,7 +91,7 @@ namespace spot
/// \brief split a separated mealy machine
///
/// 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
/// `out`, and turn the mealy machine into a game (what we call a
/// split mealy machine)
@ -197,7 +197,7 @@ namespace spot
/// \pre The machines have to be both either split or unsplit,
/// input complete and compatible. All of this is checked by assertion.
/// \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
mealy_product(const const_twa_graph_ptr& left,
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
/// 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>
/// 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
/// details.)
///

2
spot/twaalgos/parity.cc
View file

@ -133,7 +133,7 @@ namespace spot
current_odd = current_odd != toggle_style;
bool change_style = false;
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
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
/// layer receive the same color. When layer is `false`, only the
/// 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
/// color (if \a colored is false), or a useless color (if \a colored
/// 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
// GBA, and (2) if we want a deterministic parity automaton and the
// 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.
if ((via_gba || (want_parity && !a->acc().is_parity()))
&& !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
/// 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:
/// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets.
@ -69,7 +69,7 @@ namespace spot
/// conjunction of the acceptance conditions of the two input
/// 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:
/// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets.
@ -98,7 +98,7 @@ namespace spot
/// disjunction of the acceptance conditions of the two input
/// 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:
/// it usually is the acceptance condition of the other argument,
/// therefore avoiding the need to introduce new accepting sets.
@ -126,7 +126,7 @@ namespace spot
/// disjunction of the acceptance conditions of the two input
/// 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:
/// it usually is the acceptance condition of the other argument,
/// 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 out_s The destination state
/// \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.
///
/// The in_s and out_s states are owned by the
@ -141,7 +141,7 @@ namespace spot
/// \param in The source state number.
/// \param out_s The destination state
/// \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.
///
/// 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)
{
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
for (auto& e : aut.edges())
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;
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
// transition based Büchi acceptance.
// 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
// Automata", S. Krishnan, A. Puri, and R. Brayton (ISAAC'94) for
@ -381,7 +381,7 @@ namespace spot
{
true, // state based
true, // inherently weak
true, true, // determinisitic
true, true, // deterministic
true, // complete
true, // stutter inv.
});
@ -667,7 +667,7 @@ namespace spot
<< main_add << '\n';
// 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))
intersects_fin = false;

2
spot/twaalgos/remfin.hh
View file

@ -23,7 +23,7 @@
namespace spot
{
/// \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
/// 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
// of any loop.
// - 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.
//
// 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
///
/// 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.
bool is_accepting() const
{
@ -329,7 +329,7 @@ namespace spot
/// \brief True if we know that all cycles in the SCC are rejecting
///
/// 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.
bool is_rejecting() const
{
@ -509,7 +509,7 @@ namespace spot
scc_info(const scc_and_mark_filter& filt, scc_info_options options);
// we separate the two functions so that we can rename
// 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(const scc_and_mark_filter& filt)
: 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 number of runs reported by successive
// 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 "
<< "accepting, start a red dfs" << std::endl;
c.set_color(RED);
@ -244,7 +244,7 @@ namespace spot
// the test 'c.get_color() != RED' is added to limit
// the number of runs reported by successive
// calls to the check method. Without this
// functionnality, the test can be ommited.
// functionality, the test can be omitted.
trace << " The arc from "
<< a_->format_state(st_blue.front().s)
<< " 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.
/// 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 method \a check() of the checker can be called several times
/// (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.
/// 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
/// \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.
///

8
spot/twaalgos/simulation.hh
View file

@ -51,7 +51,7 @@ namespace spot
/// The resulting automaton has a named property "simulated-states",
/// 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
/// a by-product of transition prunning.
/// a by-product of transition pruning.
///
/// \param automaton the automaton to simulate.
///
@ -153,7 +153,7 @@ namespace spot
/// then reduce the automaton.
///
/// 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.
/// \return a new automaton which is at worst a copy of the received
@ -171,7 +171,7 @@ namespace spot
/// way as reduce_direct_sim().
///
/// 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.
/// \return a new automaton which is at worst a copy of the received
@ -190,7 +190,7 @@ namespace spot
/// transitions).
///
/// 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.
/// \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,
/// 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);
}

2
spot/twaalgos/stats.hh
View file

@ -51,7 +51,7 @@ namespace spot
/// \brief Compute sub statistics for an automaton.
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
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();
bv->trans_time += delta;
if (vs)
*vs << "tanslating formula done in " << delta << " seconds\n";
*vs << "translating formula done in " << delta << " seconds\n";
}
res->prop_complete(trival::maybe());

2
spot/twaalgos/synthesis.hh
View file

@ -209,7 +209,7 @@ namespace spot
};
/// \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
/// 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.
///
/// 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:
///
/** \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.
///
/// 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:
///
/** \verbatim
@ -84,7 +84,7 @@ namespace spot
end;
\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
/// of states used in spot::explicit_tau03_search. Moreover, it introduce
/// 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
/// the smallest possible parity automaton. Some of the strategies
/// 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.
///
/// 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
/// 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.
///
/// It is better to use to_parity() instead, as it will use better
@ -186,7 +186,7 @@ namespace spot
/// \ingroup twa_acc_transform
/// \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
/// 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
/// 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
/// Inf(x1)|Inf(x2)|...|Inf(xn) that may occur in clauses into a
/// 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.
///
/// 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.
///

2
spot/twaalgos/word.cc
View file

@ -206,7 +206,7 @@ namespace spot
if (word[ind] == '}')
word_parse_error(word, ind, "Expected ';' delimiter: "
"'}' 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);
if (i == std::string::npos)
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);
}
/// \brief Simplify a lasso-shapped word.
/// \brief Simplify a lasso-shaped word.
///
/// The simplified twa_word may represent a subset of the actual
/// words represented by the original twa_word. The typical
@ -79,7 +79,7 @@ namespace spot
/// \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.
///
/// 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 " +
std::to_string(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;
if (SPOT_UNLIKELY(nodes_.empty()))
// 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
/// 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
/// 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
/// 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
/// any optimality claim. The \a order_heuristics argument, enabled
/// 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
/// 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
/// - false_var = 0 1
///
/// 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
/// - 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
///
/// 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
/// represented by 4 unsigned int contiguous in memory. The 35
/// 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