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

* src/ltlvisit/randomltl.cc, src/ltlvisit/randomltl.hh: New files.

* src/ltlvisit/Makefile.am (ltlvisit_HEADERS,
libltlvisit_la_SOURCES): Distribute them.
* src/ltltest/randltl.cc: New file.
* src/ltltest/Makefile.am (LDADD): Link with ../libspot.la directly.
(noinst_PROGRAMS, randltl_SOURCES): New.
(EXTRA_DIST, CLEANFILES): The list of random formulae is now generated.
* src/ltltest/formulae.txt: Delete.
* src/ltltest/reduc.test: Use randltl to generate formulae.
* src/ltlvisit/length.cc (length_visitor): Fix computation
of the length of multops.
* src/ltlvisit/length.hh (length): Document the length of multops.
parent 72167016
2005-01-05 Alexandre Duret-Lutz <adl@src.lip6.fr>
* src/ltlvisit/randomltl.cc, src/ltlvisit/randomltl.hh: New files.
* src/ltlvisit/Makefile.am (ltlvisit_HEADERS,
libltlvisit_la_SOURCES): Distribute them.
* src/ltltest/randltl.cc: New file.
* src/ltltest/Makefile.am (LDADD): Link with ../libspot.la directly.
(noinst_PROGRAMS, randltl_SOURCES): New.
(EXTRA_DIST, CLEANFILES): The list of random formulae is now generated.
* src/ltltest/formulae.txt: Delete.
* src/ltltest/reduc.test: Use randltl to generate formulae.
* src/ltlvisit/length.cc (length_visitor): Fix computation
of the length of multops.
* src/ltlvisit/length.hh (length): Document the length of multops.
2005-01-04 Alexandre Duret-Lutz <adl@src.lip6.fr>
* src/sanity/includes.test: Also check *.hxx files.
......
## Copyright (C) 2003, 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
## Copyright (C) 2003, 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
## dpartement Systmes Rpartis Coopratifs (SRC), Universit Pierre
## et Marie Curie.
##
......@@ -21,10 +21,7 @@
AM_CPPFLAGS = -I$(srcdir)/..
AM_CXXFLAGS = $(WARNING_CXXFLAGS)
LDADD = ../ltlparse/libltlparse.la \
../ltlvisit/libltlvisit.la \
../ltlenv/libltlenv.la \
../ltlast/libltlast.la
LDADD = ../libspot.la
check_SCRIPTS = defs
# Keep this sorted alphabetically.
......@@ -41,6 +38,9 @@ check_PROGRAMS = \
tunabbrev \
tunenoform
noinst_PROGRAMS = \
randltl
equals_SOURCES = equals.cc
ltl2dot_SOURCES = readltl.cc
ltl2dot_CPPFLAGS = $(AM_CPPFLAGS) -DDOTTY
......@@ -49,6 +49,7 @@ lunabbrev_SOURCES = equals.cc
lunabbrev_CPPFLAGS = $(AM_CPPFLAGS) -DLUNABBREV
nenoform_SOURCES = equals.cc
nenoform_CPPFLAGS = $(AM_CPPFLAGS) -DNENOFORM
randltl_SOURCES = randltl.cc
reduc_SOURCES = reduc.cc
reduccmp_SOURCES = equals.cc
reduccmp_CPPFLAGS = $(AM_CPPFLAGS) -DREDUC
......@@ -60,7 +61,7 @@ tunenoform_SOURCES = equals.cc
tunenoform_CPPFLAGS = $(AM_CPPFLAGS) -DNENOFORM -DTUNABBREV
EXTRA_DIST = $(TESTS) formulae.txt
EXTRA_DIST = $(TESTS)
# Ordered by strength of the test. Test basic features first.
TESTS = \
......@@ -76,4 +77,4 @@ TESTS = \
reduc.test \
reduccmp.test
CLEANFILES = stdout expect parse.dot result.data
CLEANFILES = stdout expect parse.dot result.data formulae
This diff is collapsed.
// Copyright (C) 2003, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
// dpartement Systmes Rpartis Coopratifs (SRC), Universit Pierre
// et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (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 MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#include <iostream>
#include "ltlast/atomic_prop.hh"
#include "ltlvisit/randomltl.hh"
#include "ltlvisit/tostring.hh"
#include "ltlvisit/destroy.hh"
#include "ltlvisit/length.hh"
#include "ltlenv/defaultenv.hh"
#include "misc/random.hh"
void
syntax(char* prog)
{
std::cerr << "Usage: "<< prog << " [OPTIONS...] PROPS..." << std::endl
<< std::endl
<< "Options:" << std::endl
<< " -d dump priorities, do not generate any formula"
<< std::endl
<< " -f N the size of the formula [15]" << std::endl
<< " -F N number of formulae to generate [1]" << std::endl
<< " -p S priorities to use" << std::endl
<< " -s N seed for the random number generator" << std::endl
<< std::endl
<< "Where:" << std::endl
<< " F are floating values" << std::endl
<< " S are `KEY=F, KEY=F, ...' strings" << std::endl
<< " N are positive integers" << std::endl
<< " PROPS are the atomic properties to use on transitions"
<< std::endl
<< "Use -d to see the list of KEYs." << std::endl;
exit(2);
}
int
to_int(const char* s)
{
char* endptr;
int res = strtol(s, &endptr, 10);
if (*endptr)
{
std::cerr << "Failed to parse `" << s << "' as an integer." << std::endl;
exit(1);
}
return res;
}
int
main(int argc, char** argv)
{
bool opt_d = false;
int opt_s = 0;
int opt_f = 15;
int opt_F = 1;
char* opt_p = 0;
spot::ltl::environment& env(spot::ltl::default_environment::instance());
spot::ltl::atomic_prop_set* ap = new spot::ltl::atomic_prop_set;
int argn = 0;
if (argc <= 1)
syntax(argv[0]);
while (++argn < argc)
{
if (!strcmp(argv[argn], "-d"))
{
opt_d = true;
}
else if (!strcmp(argv[argn], "-f"))
{
if (argc < argn + 2)
syntax(argv[0]);
opt_f = to_int(argv[++argn]);
}
else if (!strcmp(argv[argn], "-F"))
{
if (argc < argn + 2)
syntax(argv[0]);
opt_F = to_int(argv[++argn]);
}
else if (!strcmp(argv[argn], "-p"))
{
if (argc < argn + 2)
syntax(argv[0]);
opt_p = argv[++argn];
}
else if (!strcmp(argv[argn], "-s"))
{
if (argc < argn + 2)
syntax(argv[0]);
opt_s = to_int(argv[++argn]);
}
else
{
ap->insert(static_cast<spot::ltl::atomic_prop*>
(env.require(argv[argn])));
}
}
spot::srand(opt_s);
spot::ltl::random_ltl rl(ap);
const char* tok = rl.parse_options(opt_p);
if (tok)
{
std::cerr << "failed to parse probabilities near `"
<< tok << "'" << std::endl;
exit(2);
}
if (opt_d)
{
rl.dump_priorities(std::cout);
}
else
{
while (opt_F--)
{
spot::ltl::formula* f = rl.generate(opt_f);
std::cout << spot::ltl::to_string(f) << std::endl;
assert(spot::ltl::length(f) <= opt_f);
spot::ltl::destroy(f);
}
}
delete ap;
}
#! /bin/sh
# Copyright (C) 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
# Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
# dpartement Systmes Rpartis Coopratifs (SRC), Universit Pierre
# et Marie Curie.
#
......@@ -26,12 +26,17 @@
set -e
FICH=${1-$srcdir/formulae.txt}
FILE=formulae
: > $FILE
for i in 10 11 12 13 14 15 16 17 18 19 20; do
./randltl -s 0 -f $i a b c -F 100 >> $FILE
./randltl -s 100 -f $i a b c d e f -F 100 >> $FILE
done
for opt in 0 1 2 3; do
rm -f result.data
cat $FICH |
cat $FILE |
while read f; do
./reduc $opt "$f" >> result.data
done
......@@ -48,3 +53,4 @@ END { print 100 - ($sum2 * 100 / $sum1); print "\n"; }
done
rm -f result.data
rm -f $FILE
## Copyright (C) 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
## Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
## dpartement Systmes Rpartis Coopratifs (SRC), Universit Pierre
## et Marie Curie.
##
......@@ -35,6 +35,7 @@ ltlvisit_HEADERS = \
lunabbrev.hh \
nenoform.hh \
postfix.hh \
randomltl.hh \
reduce.hh \
simpfg.hh \
syntimpl.hh \
......@@ -53,6 +54,7 @@ libltlvisit_la_SOURCES = \
lunabbrev.cc \
nenoform.cc \
postfix.cc \
randomltl.cc \
reduce.cc \
simpfg.cc \
syntimpl.cc \
......
// Copyright (C) 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
// dpartement Systmes Rpartis Coopratifs (SRC), Universit Pierre
// et Marie Curie.
//
......@@ -77,6 +77,7 @@ namespace spot
visit(const multop* mo)
{
unsigned mos = mo->size();
++result_;
for (unsigned i = 0; i < mos; ++i)
result_ += length(mo->nth(i));
}
......
// Copyright (C) 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
// et Marie Curie.
//
......@@ -33,7 +33,10 @@ namespace spot
///
/// The length of a formula is the number of atomic properties,
/// constants, and operators (logical and temporal) occurring in
/// the formula.
/// the formula. spot::ltl::multops count only for 1, even if
/// they have more than two operands (e.g. <code>a | b | c</code>
/// has length 4, because <code>|</code> is represented once
/// internally).
int length(const formula* f);
}
}
......
// Copyright (C) 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
// dpartement Systmes Rpartis Coopratifs (SRC), Universit Pierre
// et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (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 MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#include <cassert>
#include <algorithm>
#include "randomltl.hh"
#include "ltlast/allnodes.hh"
#include "misc/random.hh"
#include <iostream>
namespace spot
{
namespace ltl
{
namespace
{
formula*
ap_builder(const random_ltl* rl, int n)
{
assert(n == 1);
(void) n;
atomic_prop_set::const_iterator i = rl->ap()->begin();
std::advance(i, mrand(rl->ap()->size()));
return (*i)->ref();
}
formula*
true_builder(const random_ltl*, int n)
{
assert(n == 1);
(void) n;
return constant::true_instance();
}
formula*
false_builder(const random_ltl*, int n)
{
assert(n == 1);
(void) n;
return constant::false_instance();
}
template <unop::type Op>
formula*
unop_builder(const random_ltl* rl, int n)
{
assert(n >= 2);
return unop::instance(Op, rl->generate(n - 1));
}
template <binop::type Op>
formula*
binop_builder(const random_ltl* rl, int n)
{
assert(n >= 3);
--n;
int l = rrand(1, n - 1);
return binop::instance(Op, rl->generate(l), rl->generate(n - l));
}
template <multop::type Op>
formula*
multop_builder(const random_ltl* rl, int n)
{
assert(n >= 3);
--n;
int l = rrand(1, n - 1);
return multop::instance(Op, rl->generate(l), rl->generate(n - l));
}
} // anonymous
void
random_ltl::op_proba::setup(const char* name, int min_n, builder build)
{
this->name = name;
this->min_n = min_n;
this->proba = 1.0;
this->build = build;
}
namespace
{
const int proba_size = 14;
}
random_ltl::random_ltl(const atomic_prop_set* ap)
{
ap_ = ap;
proba_ = new op_proba[proba_size];
proba_[0].setup("ap", 1, ap_builder);
proba_[1].setup("false", 1, false_builder);
proba_[2].setup("true", 1, true_builder);
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>);
proba_[6].setup("X", 2, unop_builder<unop::X>);
proba_[7].setup("equiv", 3, binop_builder<binop::Equiv>);
proba_[8].setup("implies", 3, binop_builder<binop::Implies>);
proba_[9].setup("xor", 3, binop_builder<binop::Xor>);
proba_[10].setup("R", 3, binop_builder<binop::R>);
proba_[11].setup("U", 3, binop_builder<binop::U>);
proba_[12].setup("and", 3, multop_builder<multop::And>);
proba_[13].setup("or", 3, multop_builder<multop::Or>);
proba_[0].proba = ap_->size();
update_sums();
}
random_ltl::~random_ltl()
{
delete[] proba_;
}
void
random_ltl::update_sums()
{
total_1_ = 0.0;
total_2_ = 0.0;
total_2_and_more_ = 0.0;
for (int i = 0; i < proba_size; ++i)
{
if (proba_[i].min_n == 1)
total_1_ += proba_[i].proba;
else if (proba_[i].min_n == 2)
total_2_ += proba_[i].proba;
else if (proba_[i].min_n > 2)
total_2_and_more_ += proba_[i].proba;
else
assert(!"un expected 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);
}
formula*
random_ltl::generate(int n) const
{
assert(n > 0);
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);
}
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);
}
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);
}
}
const char*
random_ltl::parse_options(char* options)
{
char* key = strtok(options, "=\t, :;");
while (key)
{
char* value = strtok(0, "=\t, :;");
if (value == 0)
return key;
char* endptr;
double res = strtod(value, &endptr);
if (*endptr)
return value;
int i;
for (i = 0; i < proba_size; ++i)
{
if (('a' <= *proba_[i].name && *proba_[i].name <= 'z'
&& !strcasecmp(proba_[i].name, key))
|| !strcmp(proba_[i].name, key))
{
proba_[i].proba = res;
break;
}
}
if (i == proba_size)
return key;
key = strtok(0, "=\t, :;");
}
update_sums();
return 0;
}
std::ostream&
random_ltl::dump_priorities(std::ostream& os) const
{
for (int i = 0; i < proba_size; ++i)
os << proba_[i].name << "\t" << proba_[i].proba << std::endl;
return os;
}
} // ltl
} // spot
// Copyright (C) 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
// et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (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 MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#ifndef SPOT_LTLVISIT_RANDOMLTL_HH
# define SPOT_LTLVISIT_RANDOMLTL_HH
#include "apcollect.hh"
#include <iosfwd>
namespace spot
{
namespace ltl
{
/// \brief Generate random LTL formulae.
/// \ingroup ltl_io
///
/// This class recursively construct LTL formulae of a given size.
/// The formulae will use the use atomic propositions from the
/// set of proposition passed to the constructor, in addition to the
/// constant and all LTL operators supported by Spot.
///
/// By default each operator has equal chance to be selected.
/// Also, each atomic proposition has as much chance as each
/// constant (i.e., true and false) to be picked. This can be
/// tuned using parse_options().
class random_ltl
{
public:
/// Create a random LTL generator using atomic propositions from \a ap.
random_ltl(const atomic_prop_set* ap);
~random_ltl();
/// \brief Generate a formula of size \a n.
///
/// It is possible to obtain formulae that are smaller than \a
/// n, because some simple simplifications are performed by the
/// AST. (For instance the formula <code>a | a</code> is
/// automatically reduced to <code>a</code> by spot::ltl::multop.)
///
/// Furthermore, for the purpose of this generator,
/// <code>a | b | c</code> has length 5, while it has length
/// <code>4</code> for spot::ltl::length().
formula* generate(int n) const;
/// \brief Print the priorities of each operator, constants,
/// and atomic propositions.
std::ostream& dump_priorities(std::ostream& os) const;
/// \brief Update the priorities used to generate LTL formulae.
///
/// The initial priorities are as follows.
///
/// \verbatim
/// ap n
/// false 1