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 | List of all members
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

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

Static Public Member Functions

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

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.
 
- Static Protected Attributes inherited from libevocosm::globals
static prng g_random
 A shared random number generator.
 
static std::string g_version
 Version number.
 

Additional Inherited Members

- Protected Types inherited from libevocosm::machine_tools
enum  mutation_id {
  MUTATE_OUTPUT_SYMBOL, MUTATE_TRANSITION, MUTATE_REPLACE_STATE, MUTATE_SWAP_STATES,
  MUTATE_INIT_STATE
}
 Types of mutation supported. More...
 
- Static Protected Member Functions inherited from libevocosm::globals
static size_t rand_index (size_t n)
 Static function to allow use of g_random function pointer in random_shuffle.
 
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.
 

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.