Adding a new algorithm

In this tutorial we will learn how to code a simple optimization algorithm. We will write the algorithm so that it manage multi-objective, mixed_int, constrained optimization as this will allow us to explain all the basic PyGMO functioning. Clearly our algorithm will not be very good ... a random search always useful to benchmark against :)

In a nutshell ... we will write a class deriving from PyGMO.algorithm.base and reimplement some of its ‘virtual’ methods, the main one being evolve!!!

class my_algorithm(base):
     """
     Monte-Carlo (random sampling) algorithm implemented purely in Python.
     """

     def __init__(self,iter = 10):
             """
             Constructs a Monte-Carlo (random sampling) algorithm

             USAGE: algorithm.my_algorithm(iter = 10)

             NOTE: At the end of each iteration, the randomly generated
                     point substitutes the worst individual in the population if better

             * iter: number of random samples
             """
             #We start calling the base constructor
             super(my_algorithm,self).__init__()
             #We then define the algorithm 'private' data members
             self.__iter = iter

     #This is the 'juice' of the algorithm, the method where the actual optimzation is coded.
     def evolve(self,pop):
             #If the population is empty (i.e. no individuals) nothing happens
             if len(pop) == 0:
                     return pop

             #Here we rename some variables, in particular the problem
             prob = pop.problem
             #Its dimensions (total and continuous)
             dim, cont_dim = prob.dimension, prob.dimension - prob.i_dimension
             #And the lower/upper bounds for the chromosome
             lb, ub = prob.lb, prob.ub
             import random

             #The algorithm now starts manipulating the population
             for _ in range(self.__iter):
                     #We create a random vector within the bounds ... first the continuous part
                     tmp_cont = [random.uniform(lb[i],ub[i]) for i in range(cont_dim)]
                     #then the integer part
                     tmp_int = [float(random.randint(lb[i],ub[i])) for i in range(cont_dim,dim)]
                     #and we assemble them into one decision vector
                     tmp_x = tmp_cont + tmp_int
                     #which we push back in the population
                     pop.push_back(tmp_x)
                     #to then remove the worst individual
                     pop.erase(pop.get_worst_idx())
             #at the end of it all we return the 'evolved' population
             return pop

     def get_name(self):
             return "Monte Carlo (Python)"

     def human_readable_extra(self):
             return "n_iter=" + str(self.__n_iter)

The above code contains a lot of interesting points worth to be discussed. So, we start

• In PyGMO the decision vector (chromosome) is represented as an n-tuple. Its dimension and structure depends on the problem. Its dimension will be problem.dimension, the first prob.dimension - prob.i_dimension components will be continuous, the remaining problem.i_dimension will instead be integers.
• When a chromosome is pushed back in a population, the domination count and the domination list (data members) are automatically updated
• The get_worst_idx method sort the population with respect to the domination count, then domination list size (in inverse order)