• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• gaft-master
  • .coveragerc
  • examples
    • ex01
      • ex01.py
      • plot_animation.py
      • plot_envolution_curve.py
      • best_fit.py
    • ex02
      • plot_envolution_curve.py
      • ex02.py
      • plot_surf.py
      • best_fit.py
    • 1D_optimization_example.ipynb
  • .gitmodules
  • gaft
    • engine.py
    • components
      • population.py
      • __init__.py
      • binary_individual.py
      • individual.py
      • decimal_individual.py
    • operators
      • crossover
        • uniform_crossover.py
        • __init__.py
      • selection
        • linear_ranking_selection.py
        • roulette_wheel_selection.py
        • exponential_ranking_selection.py
        • tournament_selection.py
        • __init__.py
      • mutation
        • flip_bit_mutation.py
        • __init__.py
      • __init__.py
    • analysis
      • console_output.py
      • __init__.py
      • fitness_store.py
    • __init__.py
    • tests
      • population_test.py
      • individual_test.py
      • mpiutil_test.py
      • roulette_wheel_selection_test.py
      • uniform_crossover_test.py
      • linear_scaling_test.py
      • exponential_ranking_selection_test.py
      • dynamic_linear_scaling_test.py
      • flip_bit_mutation_test.py
      • test_all.py
      • __init__.py
      • engine_test.py
      • linear_ranking_selection_test.py
      • flip_bit_big_mutation_test.py
      • tournament_selection_test.py
    • mpiutil.py
    • plugin_interfaces
      • metaclasses.py
      • analysis.py
      • operators
        • selection.py
        • crossover.py
        • mutation.py
        • __init__.py
      • __init__.py
  • LICENSE
  • CHANGELOG.md
  • README.rst
  • setup.py
  • setup.cfg
  • .travis.yml
  • gasol
    • src
      • mpiutils.cpp
      • individual.h
      • selection.cpp
      • crossover.h
      • engine.h
      • individual.cpp
      • mpiutils.h
      • mutation.h
      • engine.cpp
      • crossover.cpp
      • selection.h
      • population.h
      • population.cpp
      • mutation.cpp
      • CMakeLists.txt
      • mpih.h
    • example
      • 1d_search.cpp
      • CMakeLists.txt
    • CMakeLists.txt
    • README.md
    • unittest
      • mpiutils_test.cpp
      • engine_test.cpp
      • individual_test.cpp
      • googletest
      • population_test.cpp
      • CMakeLists.txt
      • selection_test.cpp
      • gasol_test.cpp
      • crossover_test.cpp
      • mutation_test.cpp
  • .gitignore
  • docs
  • INSTALL.md
  • MANIFEST.in

#!/usr/bin/env python
# -*- coding: utf-8 -*-

''' Module for Individual with binary encoding.
'''
from math import log2
from itertools import accumulate
import logging

from .individual import IndividualBase
from ..mpiutil import MPIUtil

mpi = MPIUtil()


class BinaryIndividual(IndividualBase):
    '''
    Class for individual in population. Random solution will be initialized
    by default.

    :param ranges: value ranges for all entries in solution.
    :type ranges: tuple list

    :param eps: decrete precisions for binary encoding, default is 0.001.
    :type eps: float or float list (with the same length with ranges)

    .. Note:

        The decrete precisions for different components in varants may be
        adjusted automatically (possible precision loss) if eps and ranges
        are not appropriate.
    '''
    def __init__(self, ranges, eps=0.001):
        super(self.__class__, self).__init__(ranges, eps)

        # Lengths for all binary sequence in chromsome and adjusted decrete precisions.
        self.lengths = []

        for i, ((a, b), eps) in enumerate(zip(self.ranges, self.eps)):
            length = int(log2((b - a)/eps))
            precision = (b - a)/(2**length)
            self.lengths.append(length)
            self.precisions[i] = precision

        # The start and end indices for each gene segment for entries in solution.
        self.gene_indices = self._get_gene_indices()

        # Initialize individual randomly.
        self.init()

    def encode(self):
        ''' Encode solution to gene sequence in individual using different encoding.
        '''
        chromsome = []
        for var, (a, _), length, eps in zip(self.solution, self.ranges,
                                            self.lengths, self.precisions):
            chromsome.extend(self.binarize(var-a, eps, length))

        return chromsome

    def decode(self):
        ''' Decode gene sequence to solution of target function.
        '''
        solution =  [self.decimalize(self.chromsome[start: end], eps, lower_bound)
                     for (start, end), (lower_bound, _), eps in
                     zip(self.gene_indices, self.ranges, self.precisions)]
        return solution

    def _get_gene_indices(self):
        '''
        Helper function to get gene slice indices.
        '''
        end_indices = list(accumulate(self.lengths))
        start_indices = [0] + end_indices[: -1]
        return list(zip(start_indices, end_indices))

    @staticmethod
    def binarize(decimal, eps, length):
        ''' Helper function to convert a float to binary sequence.

        :param decimal: the decimal number to be converted
        :type decimal: float

        :param eps: the decrete precision of binary sequence
        :type eps: float

        :param length: the length of binary sequence.
        :type length: int
        '''
        n = int(decimal/eps)
        bin_str = '{:0>{}b}'.format(n, length)
        return [int(i) for i in bin_str]

    @staticmethod
    def decimalize(binary, eps, lower_bound):
        ''' Helper function to convert a binary sequence back to decimal number.

        :param binary: The binary list to be converted
        :type binary: list of int

        :param eps: the decrete precision of binary sequence
        :type eps: float

        :param lower_bound: the lower bound for decimal number
        :type lower_bound: float
        '''
        bin_str = ''.join([str(bit) for bit in binary])
        return lower_bound + int(bin_str, 2)*eps