Evocosm - A C++ Framework for Evolutionary Computing

Main Index

Created by Scott Robert Ladd at Coyote Gulch Productions.


Classes | Public Member Functions | Static Public Member Functions | Protected Attributes | Static Protected Attributes
libevocosm::fuzzy_machine< InSize, OutSize > Class Template Reference

A finite state machine. More...

#include <fuzzy_machine.h>

Inheritance diagram for libevocosm::fuzzy_machine< InSize, OutSize >:
libevocosm::globals libevocosm::machine_tools

List of all members.

Classes

struct  tranout_t
 Defines a transition and output state pair. More...

Public Member Functions

 fuzzy_machine (size_t a_size, double a_output_base, double a_output_range, double a_state_base, double a_state_range)
 Creation constructor.
 fuzzy_machine (size_t a_size)
 Creation constructor.
 fuzzy_machine (const fuzzy_machine< InSize, OutSize > &a_parent1, const fuzzy_machine< InSize, OutSize > &a_parent2)
 Construct via bisexual crossover.
 fuzzy_machine (const fuzzy_machine< InSize, OutSize > &a_source)
 Copy constructor.
virtual ~fuzzy_machine ()
 Virtual destructor.
fuzzy_machineoperator= (const fuzzy_machine< InSize, OutSize > &a_source)
void mutate (double a_rate)
 Mutation.
size_t transition (size_t a_input)
 Cause state transition.
void reset ()
 Reset to start-up state.
size_t size () const
 Get size.
const tranout_tget_transition (size_t a_state, size_t a_input) const
 Get a transition from the internal state table.
size_t num_input_states () const
 Get number of input states.
size_t num_output_states () const
 Get number of output states.
size_t init_state () const
 Get initial state.
size_t current_state () const
 Get current state.
tranout_t *** state_table ()
 Get current transition table.

Static Public Member Functions

static void set_mutation_weight (mutation_id a_type, double a_weight)
 Set a mutation weight.

Protected Attributes

tranout_t *** m_state_table
 State table (the machine definition)
size_t m_size
 Number of states.
size_t m_init_state
 Initial state.
size_t m_current_state
 Current state.
double m_output_base
 base value for output weights
double m_output_range
 range for output weights
double m_state_base
 base value for state weights
double m_state_range
 range for state weights

Static Protected Attributes

static mutation_selector g_selector
 Global mutation selector.

Additional Inherited Members

- Static Protected Member Functions inherited from libevocosm::globals
static void set_seed (uint32_t a_seed)
 Set the seed for the random number generator.
static uint32_t get_seed ()
 Set the seed for the random number generator.
static std::string version ()
 Get version number.
static size_t rand_index (size_t n)
 Static function to allow use of g_random function pointer in random_shuffle.

Detailed Description

template<size_t InSize, size_t OutSize>
class libevocosm::fuzzy_machine< InSize, OutSize >

The class defines an abstract fuzzy state machine that uses integer input and output types.

A fuzzy state machine differs from a finite state machine in the selection of state transitions and outputs. In a finite state machine, each input maps to specific output and state transitions for a given current state. The fuzzy state machine contains probability maps for outputs and inputs; for any given state an input, there is a probability that any valid output could be returned, for example.

Parameters:
InSizeNumber of input states
OutSizeNumber of output states

Constructor & Destructor Documentation

template<size_t InSize, size_t OutSize>
libevocosm::fuzzy_machine< InSize, OutSize >::fuzzy_machine ( size_t  a_size,
double  a_output_base,
double  a_output_range,
double  a_state_base,
double  a_state_range 
)

Creates a new finite state machine with a given number of states. The four weight values define the range of weights assigned to outputs and state transitions; the actual roulette tables are randomized in the range (base,base+range).

Parameters:
a_size- Initial number of states in this machine
a_output_base- Minimum (base) value for an output roulette wheel weight
a_output_range- Range for an output roulette wheel weight
a_state_base- Minimum (base) value for a new roulette wheel weight
a_state_range- Range for a new state roulette wheel weight

References libevocosm::globals::g_random, libevocosm::prng::get_real(), libevocosm::fuzzy_machine< InSize, OutSize >::m_current_state, libevocosm::fuzzy_machine< InSize, OutSize >::m_init_state, libevocosm::fuzzy_machine< InSize, OutSize >::m_size, libevocosm::fuzzy_machine< InSize, OutSize >::m_state_table, and libevocosm::globals::rand_index().

template<size_t InSize, size_t OutSize>
libevocosm::fuzzy_machine< InSize, OutSize >::fuzzy_machine ( size_t  a_size)
template<size_t InSize, size_t OutSize>
libevocosm::fuzzy_machine< InSize, OutSize >::fuzzy_machine ( const fuzzy_machine< InSize, OutSize > &  a_parent1,
const fuzzy_machine< InSize, OutSize > &  a_parent2 
)
template<size_t InSize, size_t OutSize>
libevocosm::fuzzy_machine< InSize, OutSize >::fuzzy_machine ( const fuzzy_machine< InSize, OutSize > &  a_source)

Creates a new fuzzy_machine identical to an existing one.

Parameters:
a_source- Object to be copied
template<size_t InSize, size_t OutSize>
libevocosm::fuzzy_machine< InSize, OutSize >::~fuzzy_machine ( )
virtual

Does nothing in the base class; exists to allow destruction of derived class objects through base class (fuzzy_machine) pointers.


Member Function Documentation

template<size_t InSize, size_t OutSize>
size_t libevocosm::fuzzy_machine< InSize, OutSize >::current_state ( ) const
inline

Returns the current (active) state.

Returns:
The current state
template<size_t InSize, size_t OutSize>
const fuzzy_machine< InSize, OutSize >::tranout_t & libevocosm::fuzzy_machine< InSize, OutSize >::get_transition ( size_t  a_state,
size_t  a_input 
) const
inline

Get a transition from the internal state table.

Parameters:
a_state- Target state
a_input- State information to return
Returns:
A transition from the internal state table.
template<size_t InSize, size_t OutSize>
size_t libevocosm::fuzzy_machine< InSize, OutSize >::init_state ( ) const
inline

Returns the initial (start up) state.

Returns:
The initial state
template<size_t InSize, size_t OutSize>
void libevocosm::fuzzy_machine< InSize, OutSize >::mutate ( double  a_rate)

Mutates a finite state machine object. The four mutations supported are:

  • Change a random output symbol
  • Change a random state transition
  • Swap two randomly-selected states
  • Randomly change the initial state Why not store the input and output sets in the machine itself? That would duplicate information across every machine of a given type, greatly increasing the memory footprint of each fuzzy_machine. The same principle holds for the mutation selector.
    Parameters:
    a_rate- Chance that any given state will mutate
template<size_t InSize, size_t OutSize>
size_t libevocosm::fuzzy_machine< InSize, OutSize >::num_input_states ( ) const
inline

Returns the number of input states

Returns:
The number of input states
template<size_t InSize, size_t OutSize>
size_t libevocosm::fuzzy_machine< InSize, OutSize >::num_output_states ( ) const
inline

Returns the number of output states

Returns:
The number of output states
template<size_t InSize, size_t OutSize>
fuzzy_machine< InSize, OutSize > & libevocosm::fuzzy_machine< InSize, OutSize >::operator= ( const fuzzy_machine< InSize, OutSize > &  a_source)
template<size_t InSize, size_t OutSize>
void libevocosm::fuzzy_machine< InSize, OutSize >::reset ( )
inline

Prepares the FSM to start running from its initial state.

template<size_t InSize, size_t OutSize>
void libevocosm::fuzzy_machine< InSize, OutSize >::set_mutation_weight ( mutation_id  a_type,
double  a_weight 
)
inlinestatic

Sets the weight value associated with a specific mutation; this changes the relative chance of this mutation happening.

Parameters:
a_type- ID of the weight to be changed
a_weight- New weight to be assigned
template<size_t InSize, size_t OutSize>
size_t libevocosm::fuzzy_machine< InSize, OutSize >::size ( ) const
inline

Returns the size of a fuzzy_machine.

Returns:
The size, in number of states
template<size_t InSize, size_t OutSize>
tranout_t*** libevocosm::fuzzy_machine< InSize, OutSize >::state_table ( )
inline

Returns the state transition table pointer.

This is a very dangerous function, as it gives unrestricted access to the transition table that defines a machine. Given the complexity of fuzzy state machines, I implemented this function for debugging purposes; it is not intended as a tool for directly altering the transition table. /return Pointer to the transition table for the target machine

template<size_t InSize, size_t OutSize>
size_t libevocosm::fuzzy_machine< InSize, OutSize >::transition ( size_t  a_input)
inline

Based on an input symbol, this function changes the state of an fuzzy_machine and returns an output symbol.

Parameters:
a_input- An input symbol
Returns:
Output value resulting from transition

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

© 1996-2005 Scott Robert Ladd. All rights reserved.
HTML documentation generated by Dimitri van Heesch's excellent Doxygen tool.