spot  1.0
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
spot::ltl::random_psl Class Reference

Generate random PSL formulae.This class recursively constructs PSL formulae of a given size. The formulae will use the use atomic propositions from the set of propositions passed to the constructor, in addition to the constant and all PSL operators supported by Spot. More...

#include <ltlvisit/randomltl.hh>

Inheritance diagram for spot::ltl::random_psl:
Inheritance graph
Collaboration diagram for spot::ltl::random_psl:
Collaboration graph

Public Member Functions

 random_psl (const atomic_prop_set *ap)
const atomic_prop_setap () const
 Return the set of atomic proposition used to build formulae.
const formulagenerate (int n) const
 Generate a formula of size n.
std::ostream & dump_priorities (std::ostream &os) const
 Print the priorities of each operator, constants, and atomic propositions.
const char * parse_options (char *options)
 Update the priorities used to generate the formulae.

Public Attributes

random_sere rs
 The SERE generator used to generate SERE subformulae.

Protected Member Functions

void setup_proba_ ()
void update_sums ()

Protected Attributes

unsigned proba_size_
op_probaproba_
double total_1_
op_probaproba_2_
double total_2_
op_probaproba_2_or_more_
double total_2_and_more_
const atomic_prop_setap_

Detailed Description

Generate random PSL formulae.

This class recursively constructs PSL formulae of a given size. The formulae will use the use atomic propositions from the set of propositions passed to the constructor, in addition to the constant and all PSL operators supported by Spot.

Constructor & Destructor Documentation

spot::ltl::random_psl::random_psl ( const atomic_prop_set ap)
Create a random PSL generator using atomic propositions from \a ap.

PSL formulae are built by combining LTL operators, plus
three operators (EConcat, UConcat, Closure) taking a SERE
as parameter.

The default priorities are defined as follows:

@verbatim 

/// ap n /// false 1 /// true 1 /// not 1 /// F 1 /// G 1 /// X 1 /// Closure 1 /// equiv 1 /// implies 1 /// xor 1 /// R 1 /// U 1 /// W 1 /// M 1 /// and 1 /// or 1 /// EConcat 1 /// UConcat 1 ///

Where \c n is the number of atomic propositions in the
set passed to the constructor.

This means that 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.

These priorities can be changed use the parse_options method.

In addition, you can set the properties of the SERE generator
used to build SERE subformulae using the parse_options method
of the \c rs attribute.  

Member Function Documentation

const atomic_prop_set* spot::ltl::random_formula::ap ( ) const
inlineinherited

Return the set of atomic proposition used to build formulae.

References spot::ltl::random_formula::ap_.

std::ostream& spot::ltl::random_formula::dump_priorities ( std::ostream &  os) const
inherited

Print the priorities of each operator, constants, and atomic propositions.

const formula* spot::ltl::random_formula::generate ( int  n) const
inherited

Generate a formula of size n.

It is possible to obtain formulae that are smaller than n, because some simple simplifications are performed by the AST. (For instance the formula a | a is automatically reduced to a by spot::ltl::multop.)

const char* spot::ltl::random_formula::parse_options ( char *  options)
inherited

Update the priorities used to generate the formulae.

options should be comma-separated list of KEY=VALUE assignments, using keys from the above list. For instance "xor=0, F=3" will prevent xor from being used, and will raise the relative probability of occurrences of the F operator.

void spot::ltl::random_ltl::setup_proba_ ( )
protectedinherited
void spot::ltl::random_formula::update_sums ( )
protectedinherited

Member Data Documentation

const atomic_prop_set* spot::ltl::random_formula::ap_
protectedinherited
op_proba* spot::ltl::random_formula::proba_
protectedinherited
op_proba* spot::ltl::random_formula::proba_2_
protectedinherited
op_proba* spot::ltl::random_formula::proba_2_or_more_
protectedinherited
unsigned spot::ltl::random_formula::proba_size_
protectedinherited
random_sere spot::ltl::random_psl::rs

The SERE generator used to generate SERE subformulae.

double spot::ltl::random_formula::total_1_
protectedinherited
double spot::ltl::random_formula::total_2_
protectedinherited
double spot::ltl::random_formula::total_2_and_more_
protectedinherited

The documentation for this class was generated from the following file:

Please comment this page and report errors about it on the RefDocComments page.
Generated on Sat Oct 27 2012 09:34:34 for spot by doxygen 1.8.1.2