Add random generators of Boolean, SERE, and PSL formula.
* src/ltlvisit/randomltl.cc, src/ltlvisit/randomltl.hh: (random_boolean, random_sere, random_psl): Add new classes. * src/ltltest/randltl.cc: Add options to support the above. Nore: the -p option was renamed to -pL for consistency, but it is still understood.
This commit is contained in:
Alexandre Duret-Lutz
parent
cc889a7f66
commit
cce6dd34f8
3 changed files with 477 additions and 70 deletions
|
|
@ -35,7 +35,7 @@ namespace spot
|
|||
{
|
||||
namespace
|
||||
{
|
||||
formula*
|
||||
static formula*
|
||||
ap_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n == 1);
|
||||
|
|
@ -45,7 +45,7 @@ namespace spot
|
|||
return (*i)->clone();
|
||||
}
|
||||
|
||||
formula*
|
||||
static formula*
|
||||
true_builder(const random_formula*, int n)
|
||||
{
|
||||
assert(n == 1);
|
||||
|
|
@ -53,7 +53,15 @@ namespace spot
|
|||
return constant::true_instance();
|
||||
}
|
||||
|
||||
formula*
|
||||
static formula*
|
||||
boolform_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 1);
|
||||
const random_sere* rs = static_cast<const random_sere*>(rl);
|
||||
return rs->rb.generate(n);
|
||||
}
|
||||
|
||||
static formula*
|
||||
false_builder(const random_formula*, int n)
|
||||
{
|
||||
assert(n == 1);
|
||||
|
|
@ -61,16 +69,32 @@ namespace spot
|
|||
return constant::false_instance();
|
||||
}
|
||||
|
||||
static formula*
|
||||
eword_builder(const random_formula*, int n)
|
||||
{
|
||||
assert(n == 1);
|
||||
(void) n;
|
||||
return constant::empty_word_instance();
|
||||
}
|
||||
|
||||
template <unop::type Op>
|
||||
formula*
|
||||
static formula*
|
||||
unop_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 2);
|
||||
return unop::instance(Op, rl->generate(n - 1));
|
||||
}
|
||||
|
||||
static formula*
|
||||
closure_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 2);
|
||||
const random_psl* rp = static_cast<const random_psl*>(rl);
|
||||
return unop::instance(unop::Closure, rp->rs.generate(n - 1));
|
||||
}
|
||||
|
||||
template <binop::type Op>
|
||||
formula*
|
||||
static formula*
|
||||
binop_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 3);
|
||||
|
|
@ -79,8 +103,49 @@ namespace spot
|
|||
return binop::instance(Op, rl->generate(l), rl->generate(n - l));
|
||||
}
|
||||
|
||||
template <binop::type Op>
|
||||
static formula*
|
||||
binop_SERELTL_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 3);
|
||||
--n;
|
||||
const random_psl* rp = static_cast<const random_psl*>(rl);
|
||||
int l = rrand(1, n - 1);
|
||||
return binop::instance(Op, rp->rs.generate(l), rl->generate(n - l));
|
||||
}
|
||||
|
||||
template <bunop::type Op>
|
||||
static formula*
|
||||
bunop_unbounded_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 2);
|
||||
return bunop::instance(Op, rl->generate(n - 1));
|
||||
}
|
||||
|
||||
template <bunop::type Op>
|
||||
static formula*
|
||||
bunop_bounded_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 2);
|
||||
int min = rrand(0, 3);
|
||||
int max = rrand(min, 4);
|
||||
return bunop::instance(Op, rl->generate(n - 1), min, max);
|
||||
}
|
||||
|
||||
template <bunop::type Op>
|
||||
static formula*
|
||||
bunop_bool_bounded_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 2);
|
||||
int min = rrand(0, 3);
|
||||
int max = rrand(min, 4);
|
||||
const random_sere* rp = static_cast<const random_sere*>(rl);
|
||||
return bunop::instance(Op, rp->rb.generate(n - 1), min, max);
|
||||
}
|
||||
|
||||
|
||||
template <multop::type Op>
|
||||
formula*
|
||||
static formula*
|
||||
multop_builder(const random_formula* rl, int n)
|
||||
{
|
||||
assert(n >= 3);
|
||||
|
|
@ -109,15 +174,24 @@ namespace spot
|
|||
for (unsigned i = 0; i < proba_size_; ++i)
|
||||
{
|
||||
if (proba_[i].min_n == 1)
|
||||
total_1_ += proba_[i].proba;
|
||||
{
|
||||
total_1_ += proba_[i].proba;
|
||||
if (proba_ + i >= proba_2_)
|
||||
total_2_ += proba_[i].proba;;
|
||||
if (proba_ + i >= proba_2_or_more_)
|
||||
total_2_and_more_ += proba_[i].proba;
|
||||
}
|
||||
else if (proba_[i].min_n == 2)
|
||||
total_2_ += proba_[i].proba;
|
||||
{
|
||||
total_2_ += proba_[i].proba;
|
||||
if (proba_ + i >= proba_2_or_more_)
|
||||
total_2_and_more_ += proba_[i].proba;
|
||||
}
|
||||
else if (proba_[i].min_n > 2)
|
||||
total_2_and_more_ += proba_[i].proba;
|
||||
else
|
||||
assert(!"unexpected max_n");
|
||||
}
|
||||
total_2_and_more_ += total_2_;
|
||||
assert(total_1_ != 0.0);
|
||||
assert(total_2_ != 0.0);
|
||||
assert(total_2_and_more_ != 0.0);
|
||||
|
|
@ -127,45 +201,34 @@ namespace spot
|
|||
random_formula::generate(int n) const
|
||||
{
|
||||
assert(n > 0);
|
||||
|
||||
double r = drand();
|
||||
op_proba* p;
|
||||
|
||||
if (n == 1)
|
||||
{
|
||||
double r = drand() * total_1_;
|
||||
op_proba* p = proba_;
|
||||
double s = p->proba;
|
||||
while (s < r)
|
||||
{
|
||||
++p;
|
||||
s += p->proba;
|
||||
}
|
||||
assert(p->min_n == 1);
|
||||
return p->build(this, n);
|
||||
r *= total_1_;
|
||||
p = proba_;
|
||||
}
|
||||
else if (n == 2)
|
||||
{
|
||||
double r = drand() * total_2_;
|
||||
op_proba* p = proba_2_;
|
||||
double s = p->proba;
|
||||
while (s < r)
|
||||
{
|
||||
++p;
|
||||
s += p->proba;
|
||||
}
|
||||
assert(p->min_n == 2);
|
||||
return p->build(this, n);
|
||||
r *= total_2_;
|
||||
p = proba_2_;
|
||||
}
|
||||
else
|
||||
{
|
||||
double r = drand() * total_2_and_more_;
|
||||
op_proba* p = proba_2_;
|
||||
double s = p->proba;
|
||||
while (s < r)
|
||||
{
|
||||
++p;
|
||||
s += p->proba;
|
||||
}
|
||||
assert(p->min_n >= 2);
|
||||
return p->build(this, n);
|
||||
r *= total_2_and_more_;
|
||||
p = proba_2_or_more_;
|
||||
}
|
||||
|
||||
double s = p->proba;
|
||||
while (s < r)
|
||||
{
|
||||
++p;
|
||||
s += p->proba;
|
||||
}
|
||||
|
||||
return p->build(this, n);
|
||||
}
|
||||
|
||||
const char*
|
||||
|
|
@ -211,15 +274,55 @@ namespace spot
|
|||
return os;
|
||||
}
|
||||
|
||||
// LTL formulae
|
||||
// SEREs
|
||||
random_sere::random_sere(const atomic_prop_set* ap)
|
||||
: random_formula(11, ap), rb(ap)
|
||||
{
|
||||
proba_[0].setup("eword", 1, eword_builder);
|
||||
proba_2_ = proba_ + 1;
|
||||
proba_2_or_more_ = proba_ + 1;
|
||||
proba_[1].setup("boolform", 1, boolform_builder);
|
||||
proba_[2].setup("star", 2, bunop_unbounded_builder<bunop::Star>);
|
||||
proba_[3].setup("star_b", 2, bunop_bounded_builder<bunop::Star>);
|
||||
proba_[4].setup("equal_b", 2, bunop_bool_bounded_builder<bunop::Equal>);
|
||||
proba_[5].setup("goto_b", 2, bunop_bool_bounded_builder<bunop::Goto>);
|
||||
proba_[6].setup("and", 3, multop_builder<multop::And>);
|
||||
proba_[7].setup("andNLM", 3, multop_builder<multop::AndNLM>);
|
||||
proba_[8].setup("or", 3, multop_builder<multop::Or>);
|
||||
proba_[9].setup("concat", 3, multop_builder<multop::Concat>);
|
||||
proba_[10].setup("fusion", 3, multop_builder<multop::Fusion>);
|
||||
|
||||
random_ltl::random_ltl(const atomic_prop_set* ap)
|
||||
: random_formula(16, ap)
|
||||
update_sums();
|
||||
}
|
||||
|
||||
// Boolean formulae
|
||||
random_boolean::random_boolean(const atomic_prop_set* ap)
|
||||
: random_formula(9, ap)
|
||||
{
|
||||
proba_[0].setup("ap", 1, ap_builder);
|
||||
proba_[0].proba = ap_->size();
|
||||
proba_[1].setup("false", 1, false_builder);
|
||||
proba_[2].setup("true", 1, true_builder);
|
||||
proba_2_ = proba_ + 3;
|
||||
proba_2_or_more_ = proba_2_ = proba_ + 3;
|
||||
proba_[3].setup("not", 2, unop_builder<unop::Not>);
|
||||
proba_[4].setup("equiv", 3, binop_builder<binop::Equiv>);
|
||||
proba_[5].setup("implies", 3, binop_builder<binop::Implies>);
|
||||
proba_[6].setup("xor", 3, binop_builder<binop::Xor>);
|
||||
proba_[7].setup("and", 3, multop_builder<multop::And>);
|
||||
proba_[8].setup("or", 3, multop_builder<multop::Or>);
|
||||
|
||||
update_sums();
|
||||
}
|
||||
|
||||
// LTL formulae
|
||||
void
|
||||
random_ltl::setup_proba_()
|
||||
{
|
||||
proba_[0].setup("ap", 1, ap_builder);
|
||||
proba_[0].proba = ap_->size();
|
||||
proba_[1].setup("false", 1, false_builder);
|
||||
proba_[2].setup("true", 1, true_builder);
|
||||
proba_2_or_more_ = proba_2_ = proba_ + 3;
|
||||
proba_[3].setup("not", 2, unop_builder<unop::Not>);
|
||||
proba_[4].setup("F", 2, unop_builder<unop::F>);
|
||||
proba_[5].setup("G", 2, unop_builder<unop::G>);
|
||||
|
|
@ -233,10 +336,36 @@ namespace spot
|
|||
proba_[13].setup("M", 3, binop_builder<binop::M>);
|
||||
proba_[14].setup("and", 3, multop_builder<multop::And>);
|
||||
proba_[15].setup("or", 3, multop_builder<multop::Or>);
|
||||
}
|
||||
|
||||
proba_[0].proba = ap_->size();
|
||||
|
||||
random_ltl::random_ltl(const atomic_prop_set* ap)
|
||||
: random_formula(16, ap)
|
||||
{
|
||||
setup_proba_();
|
||||
update_sums();
|
||||
}
|
||||
|
||||
random_ltl::random_ltl(int size, const atomic_prop_set* ap)
|
||||
: random_formula(size, ap)
|
||||
{
|
||||
setup_proba_();
|
||||
// No call to update_sums(), this functions is always
|
||||
// called by the random_psl constructor.
|
||||
}
|
||||
|
||||
// PSL
|
||||
random_psl::random_psl(const atomic_prop_set* ap)
|
||||
: random_ltl(19, ap), rs(ap)
|
||||
{
|
||||
// FIXME: This looks very fragile.
|
||||
memmove(proba_ + 8, proba_ + 7,
|
||||
((proba_ + 16) - (proba_ + 7)) * sizeof(*proba_));
|
||||
|
||||
proba_[7].setup("Closure", 2, closure_builder);
|
||||
proba_[17].setup("EConcat", 3, binop_SERELTL_builder<binop::EConcat>);
|
||||
proba_[18].setup("UConcat", 3, binop_SERELTL_builder<binop::UConcat>);
|
||||
update_sums();
|
||||
}
|
||||
|
||||
} // ltl
|
||||
} // spot
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue