Commit db4693b3 authored by Alexandre Duret-Lutz's avatar Alexandre Duret-Lutz
Browse files

Downcase a couple of misnamed class names.

* src/misc/acccompl.hh, src/misc/acccompl.cc (AccCompl): Rename to
acc_compl.
* src/tgbaalgos/simulation.cc (AccComplAutomaton, Simulation): Rename
to acc_compl_automaton and direct_simulation.  At the same time,
reindent the whole file.
* src/sanity/style.test: Detect capitalized class names.
* src/kripke/kripkeexplicit.hh (KripkePrint): Remove useless
predeclaration.
* src/tgbaalgos/simulation.hh: Typo in comment.
parent dadfbdad
// Copyright (C) 2011 Laboratoire de Recherche et Developpement
// -*- coding: utf-8 -*-
// Copyright (C) 2011, 2012 Laboratoire de Recherche et Développement
// de l'Epita (LRDE)
//
// This file is part of Spot, a model checking library.
......@@ -29,10 +30,7 @@
namespace spot
{
// Define in kripkeprint.hh
class KripkeVisitor;
/// \brief Concrete class for kripke states.
/// \brief Concrete class for kripke states.
class state_kripke : public state
{
friend class kripke_explicit;
......
......@@ -34,7 +34,7 @@ namespace spot
// we need to know wich one is go to one when true. So we are looping
// through the conditions until bdd_high is true.
// Once found, we keep only it.
bdd AccCompl::complement(const bdd acc)
bdd acc_compl::complement(const bdd acc)
{
bdd_cache_t::const_iterator it = cache_.find(acc);
if (it != cache_.end())
......@@ -70,7 +70,7 @@ namespace spot
}
bdd AccCompl::reverse_complement(const bdd acc)
bdd acc_compl::reverse_complement(const bdd acc)
{
// We are sure that if we have no acceptance condition
// the result is all_.
......
......@@ -30,14 +30,14 @@
namespace spot
{
/// \brief Help class to convert a bdd of an automaton into
/// its complement.
/// This is used when you need to complement all the acceptance
/// conditions in an automaton. For example in the simulation.
class AccCompl
/// \brief Helper class to convert acceptance conditions into promises
///
/// A set of acceptance conditions represented by the sum "à la Spot",
/// is converted into a product of promises.
class acc_compl
{
public:
AccCompl(bdd all, bdd neg)
acc_compl(bdd all, bdd neg)
: all_(all),
neg_(neg)
{
......
......@@ -67,6 +67,9 @@ for dir in "${INCDIR-..}" "${INCDIR-..}"/../iface; do
case $file in
*.test);;
*)
grep -E '[^<]class[ \t]+[A-Z]' $tmp &&
diag 'Use lower case class names.'
grep '[ ]if(' $tmp &&
diag 'Missing space after "if"'
......
......@@ -60,7 +60,7 @@
// state. This function is `update_sig'.
// - Enter in a double loop to adapt the partial order, and set
// 'relation_' accordingly. This function is `update_po'.
// 3. Rename the class (to actualize the name in the previous_it_class and
// 3. Rename the class (to actualize the name in the previous_class and
// in relation_).
// 4. Building an automaton with the result, with the condition:
// "a transition in the original automaton appears in the simulated one
......@@ -99,20 +99,20 @@ namespace spot
bdd_less_than> map_bdd_lstate;
// This class takes an automaton and creates a copy with all
// acceptance conditions complemented.
class AccComplAutomaton:
// This class takes an automaton and creates a copy with all
// acceptance conditions complemented.
class acc_compl_automaton:
public tgba_reachable_iterator_depth_first
{
{
public:
AccComplAutomaton(const tgba* a)
: tgba_reachable_iterator_depth_first(a),
size(0),
out_(new tgba_explicit_number(a->get_dict())),
ea_(a),
ac_(ea_->all_acceptance_conditions(),
ea_->neg_acceptance_conditions()),
current_max(0)
acc_compl_automaton(const tgba* a)
: tgba_reachable_iterator_depth_first(a),
size(0),
out_(new tgba_explicit_number(a->get_dict())),
ea_(a),
ac_(ea_->all_acceptance_conditions(),
ea_->neg_acceptance_conditions()),
current_max(0)
{
init_ = ea_->get_init_state();
out_->set_init_state(get_state(init_));
......@@ -122,10 +122,10 @@ namespace spot
get_state(const state* s)
{
if (state2int.find(s) == state2int.end())
{
state2int[s] = ++current_max;
previous_it_class_[out_->add_state(current_max)] = bddfalse;
}
{
state2int[s] = ++current_max;
previous_class_[out_->add_state(current_max)] = bddfalse;
}
return state2int[s];
}
......@@ -155,7 +155,7 @@ namespace spot
++size;
}
~AccComplAutomaton()
~acc_compl_automaton()
{
init_->destroy();
}
......@@ -163,128 +163,128 @@ namespace spot
public:
size_t size;
tgba_explicit_number* out_;
map_state_bdd previous_it_class_;
map_state_bdd previous_class_;
private:
const tgba* ea_;
AccCompl ac_;
acc_compl ac_;
map_state_unsigned state2int;
unsigned current_max;
state* init_;
};
};
class Simulation
class direct_simulation
{
// Shortcut used in update_po and go_to_next_it.
typedef std::map<bdd, bdd, bdd_less_than> map_bdd_bdd;
public:
Simulation(const tgba* t)
: a_(0),
po_size_(0),
all_class_var_(bddtrue)
{
AccComplAutomaton
acc_compl(t);
// We'll start our work by replacing all the acceptance
// conditions by their complement.
acc_compl.run();
a_ = acc_compl.out_;
// We use the previous run to know the size of the
// automaton, and to class all the reachable states in the
// map previous_it_class_.
size_a_ = acc_compl.size;
// Now, we have to get the bdd which will represent the
// class. We register one bdd by state, because in the worst
// case, |Class| == |State|.
unsigned set_num = a_->get_dict()
->register_anonymous_variables(size_a_, a_);
bdd init = bdd_ithvar(set_num);
// Because we have already take the first element which is init.
++set_num;
used_var_.push_back(init);
all_class_var_ = init;
// We fetch the result the run of AccComplAutomaton which
// has recorded all the state in a hash table, and we set all
// to init.
for (map_state_bdd::iterator it
= acc_compl.previous_it_class_.begin();
it != acc_compl.previous_it_class_.end();
++it)
// Shortcut used in update_po and go_to_next_it.
typedef std::map<bdd, bdd, bdd_less_than> map_bdd_bdd;
public:
direct_simulation(const tgba* t)
: a_(0),
po_size_(0),
all_class_var_(bddtrue)
{
acc_compl_automaton
acc_compl(t);
// We'll start our work by replacing all the acceptance
// conditions by their complement.
acc_compl.run();
a_ = acc_compl.out_;
// We use the previous run to know the size of the
// automaton, and to class all the reachable states in the
// map previous_class_.
size_a_ = acc_compl.size;
// Now, we have to get the bdd which will represent the
// class. We register one bdd by state, because in the worst
// case, |Class| == |State|.
unsigned set_num = a_->get_dict()
->register_anonymous_variables(size_a_, a_);
bdd init = bdd_ithvar(set_num);
// Because we have already take the first element which is init.
++set_num;
used_var_.push_back(init);
all_class_var_ = init;
// We fetch the result the run of acc_compl_automaton which
// has recorded all the state in a hash table, and we set all
// to init.
for (map_state_bdd::iterator it
= acc_compl.previous_class_.begin();
it != acc_compl.previous_class_.end();
++it)
{
previous_it_class_[it->first] = init;
previous_class_[it->first] = init;
}
// Put all the anonymous variable in a queue, and record all
// of these in a variable all_class_var_ which will be used
// to understand the destination part in the signature when
// building the resulting automaton.
for (unsigned i = set_num; i < set_num + size_a_ - 1; ++i)
// Put all the anonymous variable in a queue, and record all
// of these in a variable all_class_var_ which will be used
// to understand the destination part in the signature when
// building the resulting automaton.
for (unsigned i = set_num; i < set_num + size_a_ - 1; ++i)
{
free_var_.push(i);
all_class_var_ &= bdd_ithvar(i);
}
relation_[init] = init;
}
relation_[init] = init;
}
// Reverse all the acceptance condition at the destruction of
// this object, because it occurs after the return of the
// function simulation.
~Simulation()
{
delete a_;
}
// Reverse all the acceptance condition at the destruction of
// this object, because it occurs after the return of the
// function simulation.
~direct_simulation()
{
delete a_;
}
// We update the name of the class.
void update_previous_it_class()
{
std::list<bdd>::iterator it_bdd = used_var_.begin();
// We run through the map bdd/list<state>, and we update
// the previous_it_class_ with the new data.
it_bdd = used_var_.begin();
for (map_bdd_lstate::iterator it = bdd_lstate_.begin();
it != bdd_lstate_.end();
++it)
// We update the name of the class.
void update_previous_class()
{
std::list<bdd>::iterator it_bdd = used_var_.begin();
// We run through the map bdd/list<state>, and we update
// the previous_class_ with the new data.
it_bdd = used_var_.begin();
for (map_bdd_lstate::iterator it = bdd_lstate_.begin();
it != bdd_lstate_.end();
++it)
{
for (std::list<const state*>::iterator it_s = it->second.begin();
it_s != it->second.end();
++it_s)
{
// If the signature of a state is bddfalse (which is
// roughly equivalent to no transition) the class of
// this state is bddfalse instead of an anonymous
// variable. It allows simplifications in the signature
// by removing a transition which has as a destination a
// state with no outgoing transition.
if (it->first == bddfalse)
previous_it_class_[*it_s] = bddfalse;
else
previous_it_class_[*it_s] = *it_bdd;
}
{
// If the signature of a state is bddfalse (which is
// roughly equivalent to no transition) the class of
// this state is bddfalse instead of an anonymous
// variable. It allows simplifications in the signature
// by removing a transition which has as a destination a
// state with no outgoing transition.
if (it->first == bddfalse)
previous_class_[*it_s] = bddfalse;
else
previous_class_[*it_s] = *it_bdd;
}
++it_bdd;
}
}
// The core loop of the algorithm.
tgba* run()
{
unsigned int nb_partition_before = 0;
unsigned int nb_po_before = po_size_ - 1;
while (nb_partition_before != bdd_lstate_.size()
|| nb_po_before != po_size_)
}
// The core loop of the algorithm.
tgba* run()
{
unsigned int nb_partition_before = 0;
unsigned int nb_po_before = po_size_ - 1;
while (nb_partition_before != bdd_lstate_.size()
|| nb_po_before != po_size_)
{
update_previous_it_class();
update_previous_class();
nb_partition_before = bdd_lstate_.size();
bdd_lstate_.clear();
nb_po_before = po_size_;
......@@ -293,17 +293,17 @@ namespace spot
go_to_next_it();
}
update_previous_it_class();
return build_result();
}
update_previous_class();
return build_result();
}
// Take a state and compute its signature.
bdd compute_sig(const state* src)
{
tgba_succ_iterator* sit = a_->succ_iter(src);
bdd res = bddfalse;
// Take a state and compute its signature.
bdd compute_sig(const state* src)
{
tgba_succ_iterator* sit = a_->succ_iter(src);
bdd res = bddfalse;
for (sit->first(); !sit->done(); sit->next())
for (sit->first(); !sit->done(); sit->next())
{
const state* dst = sit->current_state();
bdd acc = sit->current_acceptance_conditions();
......@@ -312,65 +312,65 @@ namespace spot
// the label of the transition and the class of the
// destination and all the class it implies.
bdd to_add = acc & sit->current_condition()
& relation_[previous_it_class_[dst]];
& relation_[previous_class_[dst]];
res |= to_add;
dst->destroy();
}
delete sit;
return res;
}
void update_sig()
{
// At this time, current_class_ must be empty. It implies
// that the "previous_it_class_ = current_class_" must be
// done before.
assert(current_class_.empty());
// Here we suppose that previous_it_class_ always contains
// all the reachable states of this automaton. We do not
// have to make (again) a traversal. We just have to run
// through this map.
for (map_state_bdd::iterator it = previous_it_class_.begin();
it != previous_it_class_.end();
++it)
delete sit;
return res;
}
void update_sig()
{
// At this time, current_class_ must be empty. It implies
// that the "previous_class_ = current_class_" must be
// done before.
assert(current_class_.empty());
// Here we suppose that previous_class_ always contains
// all the reachable states of this automaton. We do not
// have to make (again) a traversal. We just have to run
// through this map.
for (map_state_bdd::iterator it = previous_class_.begin();
it != previous_class_.end();
++it)
{
const state* src = it->first;
bdd_lstate_[compute_sig(src)].push_back(src);
}
}
}
// This method rename the color set, update the partial order.
void go_to_next_it()
{
int nb_new_color = bdd_lstate_.size() - used_var_.size();
// This method rename the color set, update the partial order.
void go_to_next_it()
{
int nb_new_color = bdd_lstate_.size() - used_var_.size();
for (int i = 0; i < nb_new_color; ++i)
for (int i = 0; i < nb_new_color; ++i)
{
assert(!free_var_.empty());
used_var_.push_back(bdd_ithvar(free_var_.front()));
free_var_.pop();
}
assert(bdd_lstate_.size() == used_var_.size());
assert(bdd_lstate_.size() == used_var_.size());
// Now we make a temporary hash_table which links the tuple
// "C^(i-1), N^(i-1)" to the new class coloring. If we
// rename the class before updating the partial order, we
// loose the information, and if we make it after, I can't
// figure out how to apply this renaming on rel_.
// It adds a data structure but it solves our problem.
map_bdd_bdd now_to_next;
// Now we make a temporary hash_table which links the tuple
// "C^(i-1), N^(i-1)" to the new class coloring. If we
// rename the class before updating the partial order, we
// loose the information, and if we make it after, I can't
// figure out how to apply this renaming on rel_.
// It adds a data structure but it solves our problem.
map_bdd_bdd now_to_next;
std::list<bdd>::iterator it_bdd = used_var_.begin();
std::list<bdd>::iterator it_bdd = used_var_.begin();
for (map_bdd_lstate::iterator it = bdd_lstate_.begin();
it != bdd_lstate_.end();
++it)
for (map_bdd_lstate::iterator it = bdd_lstate_.begin();
it != bdd_lstate_.end();
++it)
{
// If the signature of a state is bddfalse (which is
// roughly equivalent to no transition) the class of
......@@ -385,85 +385,85 @@ namespace spot
++it_bdd;
}
update_po(now_to_next);
}
// This function computes the new po with previous_it_class_
// and the argument. `now_to_next' contains the relation
// between the signature and the future name of the class.
void update_po(const map_bdd_bdd& now_to_next)
{
// This loop follows the pattern given by the paper.
// foreach class do
// | foreach class do
// | | update po if needed
// | od
// od
for (map_bdd_bdd::const_iterator it1 = now_to_next.begin();
it1 != now_to_next.end();
++it1)
update_po(now_to_next);
}
// This function computes the new po with previous_class_
// and the argument. `now_to_next' contains the relation
// between the signature and the future name of the class.
void update_po(const map_bdd_bdd& now_to_next)
{
// This loop follows the pattern given by the paper.
// foreach class do
// | foreach class do
// | | update po if needed
// | od
// od
for (map_bdd_bdd::const_iterator it1 = now_to_next.begin();
it1 != now_to_next.end();
++it1)
{
bdd accu = it1->second;
for (map_bdd_bdd::const_iterator it2 = now_to_next.begin();
it2 != now_to_next.end();
++it2)
{
// Skip the case managed by the initialization of accu.
if (it1 == it2)
continue;
// We detect that "a&b -> a" by testing "a&b = a".
if ((it1->first & it2->first) == (it1->first))
{
accu &= it2->second;
++po_size_;
}
}
{
// Skip the case managed by the initialization of accu.
if (it1 == it2)
continue;
// We detect that "a&b -> a" by testing "a&b = a".
if ((it1->first & it2->first) == (it1->first))
{
accu &= it2->second;
++po_size_;
}
}
relation_[it1->second] = accu;
}
}
// Build the minimal resulting automaton.
tgba* build_result()
{
// Now we need to create a state per partition. But the
// problem is that we don't know exactly the class. We know
// that it is a combination of the acceptance condition
// contained in all_class_var_. So we need to make a little
// workaround. We will create a map which will associate bdd
// and unsigned.
std::map<bdd, unsigned, bdd_less_than> bdd2state;
unsigned int current_max = 0;
bdd all_acceptance_conditions
= a_->all_acceptance_conditions();
// We have all the a_'s acceptances conditions
// complemented. So we need to complement it when adding a
// transition. We *must* keep the complemented because it
// is easy to know if an acceptance condition is maximal or
// not.
AccCompl reverser(all_acceptance_conditions,
a_->neg_acceptance_conditions());
typedef tgba_explicit_number::transition trs;
tgba_explicit_number* res
= new tgba_explicit_number(a_->get_dict());
res->set_acceptance_conditions
(all_acceptance_conditions);
bdd sup_all_acc = bdd_support(all_acceptance_conditions);
// Non atomic propositions variables (= acc and class)
bdd nonapvars = sup_all_acc & bdd_support(all_class_var_);
// Create one state per partition.
for (map_bdd_lstate::iterator it = bdd_lstate_.begin();
it != bdd_lstate_.end(); ++it)
}
// Build the minimal resulting automaton.
tgba* build_result()
{
// Now we need to create a state per partition. But the
// problem is that we don't know exactly the class. We know
// that it is a combination of the acceptance condition
// contained in all_class_var_. So we need to make a little
// workaround. We will create a map which will associate bdd
// and unsigned.
std::map<bdd, unsigned, bdd_less_than> bdd2state;
unsigned int current_max = 0;
bdd all_acceptance_conditions
= a_->all_acceptance_conditions();
// We have all the a_'s acceptances conditions
// complemented. So we need to complement it when adding a