extl/intelligence/ga/probability_traits.h

   1 /* ///////////////////////////////////////////////////////////////////////
   2  * File:                probability_traits.h
   3  *
   4  * Created:             08.09.09
   5  * Updated:             08.09.11
   6  *
   7  * Brief: The probability_traits class
   8  *
   9  * [<Home>]
  10  * Copyright (c) 2008-2020, Waruqi All rights reserved.
  11  * //////////////////////////////////////////////////////////////////// */
  12
  13 #ifndef EXTL_INTELLIGENCE_GA_PROBABILITY_TRAITS_H
  14 #define EXTL_INTELLIGENCE_GA_PROBABILITY_TRAITS_H
  15
  16 /*!\file probability_traits.h
  17  * \brief The probability_traits class
  18  */
  19 #ifndef __cplusplus
  20 #       error probability_traits.h need be supported by c++.
  21 #endif
  22
  23 /* ///////////////////////////////////////////////////////////////////////
  24  * Includes
  25  */
  26 #include "prefix.h"
  27
  28 /* ///////////////////////////////////////////////////////////////////////
  29  * ::extl::intelligence namespace
  30  */
  31 EXTL_INTELLIGENCE_BEGIN_WHOLE_NAMESPACE
  32
  33 /*!\brief proportional_probability_traits
  34  *
  35  * \param Pop The population type
  36  *
  37  * \ingroup extl_group_intelligence
  38  */
  39 template<typename_param_k Pop>
  40 class proportional_probability_traits
  41 {
  42         /// \name Types
  43         /// @{
  44         public:
  45                 typedef Pop                                                                                                     population_type;
  46                 typedef typename_type_k population_type::individual_type        individual_type;
  47                 typedef typename_type_k population_type::size_type                      size_type;
  48                 typedef typename_type_k population_type::bool_type                      bool_type;
  49                 typedef typename_type_k population_type::float_type                     float_type;
  50                 typedef typename_type_k population_type::index_type                     index_type;
  51                 typedef typename_type_k population_type::int_type                       int_type;
  52         /// @}
  53
  54         /// \name Methods
  55         /// @{
  56         public:
  57                 /// p = fit_i / fit_sum
  58                 void probability(population_type& pop)
  59                 {
  60                         EXTL_ASSERT(pop.size() > 0);
  61
  62                         size_type n = pop.size();
  63
  64                         // pop.fsum() != 0
  65                         if (pop.fsum())
  66                         {
  67                                 for (size_type i = 0; i < n; ++i)
  68                                 {
  69                                         pop.individual(i).probability(pop.individual(i).fitness() / pop.fsum());
  70                                 }
  71                         }
  72                         else
  73                         {
  74                                 for (size_type i = 0; i < n; ++i)
  75                                 {
  76                                         pop.individual(i).probability(1);
  77                                 }
  78                         }
  79                 }
  80         /// @}
  81 };
  82
  83 /*!\brief proportional_probability_traits
  84  *
  85  * \param Pop The population type
  86  * \param SP The selection pressure(SP%)
  87  *
  88  * \ingroup extl_group_intelligence
  89  */
  90 template<       typename_param_k Pop
  91                 ,       e_size_t SP/* = 30*/
  92                 >
  93 struct rank_based_probability_traits
  94 {
  95         /// \name Types
  96         /// @{
  97         public:
  98                 typedef Pop                                                                                                                     population_type;
  99                 typedef typename_type_k population_type::individual_type                        individual_type;
 100                 typedef typename_type_k population_type::size_type                                      size_type;
 101                 typedef typename_type_k population_type::bool_type                                      bool_type;
 102                 typedef typename_type_k population_type::float_type                                     float_type;
 103                 typedef typename_type_k population_type::index_type                                     index_type;
 104                 typedef typename_type_k population_type::int_type                                       int_type;
 105                 typedef typename_type_k buffer_selector<index_type>::buffer_type        index_buffer_type;
 106         /// @}
 107
 108         private:
 109                 class pred
 110                 {
 111                         private:
 112                                 population_type& m_pop;
 113
 114                         public:
 115                                 pred(population_type& pop)
 116                                         : m_pop(pop)
 117                                 {
 118                                 }
 119
 120                         public:
 121                                 bool_type operator()(index_type lhs, index_type rhs)
 122                                 {
 123                                         return m_pop.individual(lhs).fitness() > m_pop.individual(rhs).fitness();
 124                                 }
 125                 };
 126
 127         /// \name Methods
 128         /// @{
 129         public:
 130                 /// fitness sort => p = q * (1 - q)^i
 131                 void probability(population_type& pop)
 132                 {
 133                         size_type pop_n = pop.size();
 134                         EXTL_ASSERT(pop_n > 0);
 135
 136                         // init indices
 137                         index_buffer_type indices(pop.size());
 138
 139                         size_type i;
 140                         for (i = 0; i < pop_n; ++i) indices[i] = i;
 141
 142                         // fitness sort in descending order
 143                         //std_sort(indices.data(), indices.data() + indices.size(), pred(pop));
 144                         std_sort(indices.begin(), indices.end(), pred(pop));
 145
 146                         // calculate probability
 147                         float_type q = float_type(SP) / 100;    // selection pressure
 148                         //float_type q = pop.fsum() > 0? (pop.individual(indices[0]).fitness() / pop.fsum()) : 0.9;
 149                         float_type p = q * (1 - q);
 150                         for (i = 0; i < pop_n; ++i)
 151                         {
 152                                 pop.individual(indices[i]).probability(p);
 153                                 p *= (1 - q);
 154                         }
 155                 }
 156         /// @}
 157 };
 158
 159 /* ///////////////////////////////////////////////////////////////////////
 160  * ::extl::intelligence namespace
 161  */
 162 EXTL_INTELLIGENCE_END_WHOLE_NAMESPACE
 163
 164 /* //////////////////////////////////////////////////////////////////// */
 165 #endif /* EXTL_INTELLIGENCE_GA_PROBABILITY_TRAITS_H */
 166 /* //////////////////////////////////////////////////////////////////// */