53 #if !defined(LIBEVOCOSM_FUZZY_MACHINE_H)
54 #define LIBEVOCOSM_FUZZY_MACHINE_H
67 #include "evocommon.h"
68 #include "machine_tools.h"
86 template <
size_t InSize,
size_t OutSize>
100 tranout_t(
double * state_weights,
size_t num_states,
double * output_weights)
101 : m_new_state(state_weights, num_states),
102 m_output(output_weights, OutSize)
109 : m_new_state(source.m_new_state),
110 m_output(source.m_output)
136 double a_output_base,
137 double a_output_range,
139 double a_state_range);
191 void mutate(
double a_rate);
200 static void set_mutation_weight(mutation_id a_type,
double a_weight);
209 size_t transition(
size_t a_input);
231 const tranout_t & get_transition(
size_t a_state,
size_t a_input)
const;
238 size_t num_input_states()
const;
245 size_t num_output_states()
const;
252 size_t init_state()
const;
259 size_t current_state()
const;
274 return m_state_table;
278 void dump(
const char * description, ostream & a_stream = cerr)
const;
318 template <
size_t InSize,
size_t OutSize>
322 template <
size_t InSize,
size_t OutSize>
325 for (
size_t s = 0; s < m_size; ++s)
327 for (
size_t i = 0; i < InSize; ++i)
328 delete m_state_table[s][i];
330 delete [] m_state_table[s];
333 delete [] m_state_table;
337 template <
size_t InSize,
size_t OutSize>
338 void fuzzy_machine<InSize,OutSize>::deep_copy(
const fuzzy_machine<InSize,OutSize> & a_source)
341 m_state_table =
new tranout_t ** [m_size];
343 for (
size_t s = 0; s < m_size; ++s)
346 m_state_table[s] =
new tranout_t * [InSize];
349 for (
size_t i = 0; i < InSize; ++i)
350 m_state_table[s][i] =
new tranout_t(*(a_source.m_state_table[s][i]));
355 template <
size_t InSize,
size_t OutSize>
357 double a_output_base,
358 double a_output_range,
360 double a_state_range)
361 : m_state_table(NULL),
365 m_output_base(a_output_base),
366 m_output_range(a_output_range),
367 m_state_base(a_state_base),
368 m_state_range(a_state_range)
372 throw std::runtime_error(
"invalid fuzzy_machine creation parameters");
378 double * output_weights =
new double[OutSize];
379 double * state_weights =
new double[
m_size];
381 for (
size_t s = 0; s <
m_size; ++s)
386 for (
size_t i = 0; i < InSize; ++i)
391 for (n = 0; n < OutSize; ++n)
394 for (n = 0; n <
m_size; ++n)
402 delete [] output_weights;
403 delete [] state_weights;
411 template <
size_t InSize,
size_t OutSize>
413 : m_state_table(NULL),
418 m_output_range(100.0),
424 throw std::runtime_error(
"invalid fuzzy_machine creation parameters");
430 double * output_weights =
new double[OutSize];
431 double * state_weights =
new double[
m_size];
433 for (
size_t s = 0; s <
m_size; ++s)
438 for (
size_t i = 0; i < InSize; ++i)
443 for (n = 0; n < OutSize; ++n)
444 output_weights[n] = 1.0;
448 for (n = 0; n <
m_size; ++n)
449 state_weights[n] = 1.0;
458 delete [] output_weights;
459 delete [] state_weights;
467 template <
size_t InSize,
size_t OutSize>
469 : m_state_table(NULL),
470 m_size(a_parent1.m_size),
473 m_output_base(a_parent1.m_output_base),
474 m_output_range(a_parent1.m_output_range),
475 m_state_base(a_parent1.m_state_base),
476 m_state_range(a_parent1.m_state_range)
479 cerr <<
"\n<< crossover operation >>\n";
480 a_parent1.dump(
"PARENT1");
481 a_parent2.dump(
"PARENT2");
485 deep_copy(a_parent1);
488 if ((a_parent1.
m_size != a_parent2.
m_size) || (&a_parent1 == &a_parent2))
495 cerr <<
"crossover at " << x <<
"\n";
498 for (
size_t n = x; n <
m_size; ++n)
501 for (
size_t i = 0; i < InSize; ++i)
523 template <
size_t InSize,
size_t OutSize>
525 : m_state_table(NULL),
526 m_size(a_source.m_size),
527 m_init_state(a_source.m_init_state),
528 m_current_state(a_source.m_current_state),
529 m_output_base(a_source.m_output_base),
530 m_output_range(a_source.m_output_range),
531 m_state_base(a_source.m_state_base),
532 m_state_range(a_source.m_state_range)
539 template <
size_t InSize,
size_t OutSize>
546 template <
size_t InSize,
size_t OutSize>
568 template <
size_t InSize,
size_t OutSize>
571 g_selector.set_weight(a_type,a_weight);
575 template <
size_t InSize,
size_t OutSize>
581 cerr <<
"\n<< mutation operation >>\n";
585 for (
size_t n = 0; n < m_size; ++n)
587 if (g_random.get_real() < a_rate)
590 switch (g_selector.get_index())
592 case MUTATE_OUTPUT_SYMBOL:
595 size_t state = rand_index(m_size);
596 size_t input = rand_index(InSize);
597 size_t index = rand_index(OutSize);
600 cerr <<
"MUTATE_OUTPUT_SYMBOL, state " << state <<
", input " << input <<
", index " << index <<
"\n";
603 double new_weight = m_output_base + m_output_range * g_random.get_real();
604 m_state_table[state][input]->m_output.set_weight(index,new_weight);
607 case MUTATE_TRANSITION:
610 size_t state = rand_index(m_size);
611 size_t input = rand_index(InSize);
612 size_t index = rand_index(m_size);
615 cerr <<
"MUTATE_TRANSITION, state " << state <<
", input " << input <<
", index " << index <<
"\n";
618 double new_weight = m_state_base + m_state_range * g_random.get_real();
619 m_state_table[state][input]->m_new_state.set_weight(index,new_weight);
622 case MUTATE_REPLACE_STATE:
625 size_t state = rand_index(m_size);
628 cerr <<
"REPLACE_STATE, state " << state <<
"\n";
632 delete [] m_state_table[state];
633 m_state_table[state] =
new tranout_t * [InSize];
636 double * output_weights =
new double[OutSize];
637 double * state_weights =
new double[m_size];
639 for (
size_t i = 0; i < InSize; ++i)
644 for (n = 0; n < OutSize; ++n)
645 output_weights[n] = 1.0;
647 output_weights[rand_index(OutSize)] = 100.0;
649 for (n = 0; n < m_size; ++n)
650 state_weights[n] = 1.0;
652 state_weights[rand_index(m_size)] = 100.0;
655 m_state_table[state][i] =
new tranout_t(state_weights,m_size,output_weights);
658 delete [] output_weights;
659 delete [] state_weights;
663 case MUTATE_SWAP_STATES:
666 size_t state1 = rand_index(m_size);
670 state2 =
static_cast<size_t>(rand_index(m_size));
671 while (state2 == state1);
674 cerr <<
"MUTATE_SWAP_STATES, " << state1 <<
" with " << state2 <<
"\n";
677 for (
size_t i = 0; i < InSize; ++i)
679 tranout_t * temp = m_state_table[state1][i];
680 m_state_table[state1][i] = m_state_table[state2][i];
681 m_state_table[state2][i] = temp;
686 case MUTATE_INIT_STATE:
690 cerr <<
"MUTATE_INIT_STATE\n";
692 m_init_state = rand_index(m_size);
697 cerr <<
"UNKNOWN MUTATION!\n";
705 m_current_state = m_init_state;
712 template <
size_t InSize,
size_t OutSize>
716 size_t output = m_state_table[m_current_state][a_input]->m_output.get_index();
719 m_current_state = m_state_table[m_current_state][a_input]->m_new_state.get_index();
726 template <
size_t InSize,
size_t OutSize>
729 m_current_state = m_init_state;
733 template <
size_t InSize,
size_t OutSize>
740 template <
size_t InSize,
size_t OutSize>
743 return *m_state_table[a_state][a_input];
747 template <
size_t InSize,
size_t OutSize>
754 template <
size_t InSize,
size_t OutSize>
761 template <
size_t InSize,
size_t OutSize>
768 template <
size_t InSize,
size_t OutSize>
771 return m_current_state;
775 template <
size_t InSize,
size_t OutSize>
778 a_stream <<
"----------\nDumping machine " << description <<
" (" << hex <<
this
779 <<
")\ninitial state = " << m_init_state
780 <<
"\ncurrent state = " << m_current_state <<
"\n\n";
782 for (
size_t s = 0; s < m_size; ++s)
784 a_stream <<
"state " << s;
786 for (
size_t i = 0; i < InSize; ++i)
790 a_stream <<
"\n output weights:";
792 for (n = 0; n < OutSize; ++n)
793 a_stream <<
" " << m_state_table[s][i]->m_output.get_weight(n);
795 a_stream <<
"\n state weights:";
797 for (n = 0; n < m_size; ++n)
798 a_stream <<
" " << m_state_table[s][i]->m_new_state.get_weight(n);
804 a_stream <<
"----------" << endl;
Wraps a roulette wheel for selecting mutations.
Definition: machine_tools.h:95
double m_output_base
base value for output weights
Definition: fuzzy_machine.h:302
size_t init_state() const
Get initial state.
Definition: fuzzy_machine.h:762
fuzzy_machine(size_t a_size, double a_output_base, double a_output_range, double a_state_base, double a_state_range)
Creation constructor.
Definition: fuzzy_machine.h:356
roulette_wheel m_new_state
The state to be transitioned to.
Definition: fuzzy_machine.h:94
mutation_id
Types of mutation supported.
Definition: machine_tools.h:69
tranout_t *** m_state_table
State table (the machine definition)
Definition: fuzzy_machine.h:290
A set of common tools for finite state machines.
Definition: machine_tools.h:65
tranout_t(double *state_weights, size_t num_states, double *output_weights)
Creation Constructor.
Definition: fuzzy_machine.h:100
size_t num_output_states() const
Get number of output states.
Definition: fuzzy_machine.h:755
double m_state_range
range for state weights
Definition: fuzzy_machine.h:311
tranout_t(const tranout_t &source)
Copy constructor.
Definition: fuzzy_machine.h:108
static void set_mutation_weight(mutation_id a_type, double a_weight)
Set a mutation weight.
Definition: fuzzy_machine.h:569
Defines a transition and output state pair.
Definition: fuzzy_machine.h:91
A toolkit and framework for implementing evolutionary algorithms.
Definition: analyzer.h:60
static mutation_selector g_selector
Global mutation selector.
Definition: fuzzy_machine.h:314
size_t size() const
Get size.
Definition: fuzzy_machine.h:734
fuzzy_machine & operator=(const fuzzy_machine< InSize, OutSize > &a_source)
Definition: fuzzy_machine.h:547
Elements shared by all classes in Evocosm.
Definition: evocommon.h:117
static prng g_random
A shared random number generator.
Definition: evocommon.h:127
A simulated roulette wheel for weighted selection.
Definition: roulette.h:89
size_t m_size
Number of states.
Definition: fuzzy_machine.h:293
size_t num_input_states() const
Get number of input states.
Definition: fuzzy_machine.h:748
double m_state_base
base value for state weights
Definition: fuzzy_machine.h:308
static size_t rand_index(size_t n)
Static function to allow use of g_random function pointer in random_shuffle.
Definition: evocommon.h:121
size_t transition(size_t a_input)
Cause state transition.
Definition: fuzzy_machine.h:713
roulette_wheel m_output
The output value.
Definition: fuzzy_machine.h:97
double m_output_range
range for output weights
Definition: fuzzy_machine.h:305
void mutate(double a_rate)
Mutation.
Definition: fuzzy_machine.h:576
void reset()
Reset to start-up state.
Definition: fuzzy_machine.h:727
double get_real()
get the next value in the range [0,1)
Definition: evocommon.h:106
virtual ~fuzzy_machine()
Virtual destructor.
Definition: fuzzy_machine.h:540
A finite state machine.
Definition: fuzzy_machine.h:87
size_t current_state() const
Get current state.
Definition: fuzzy_machine.h:769
size_t m_init_state
Initial state.
Definition: fuzzy_machine.h:296
tranout_t *** state_table()
Get current transition table.
Definition: fuzzy_machine.h:272
size_t m_current_state
Current state.
Definition: fuzzy_machine.h:299
const tranout_t & get_transition(size_t a_state, size_t a_input) const
Get a transition from the internal state table.
Definition: fuzzy_machine.h:741