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

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.