Genetic Algorithm

• Elite children are the individuals in the current generation with the best fitness values. These individuals automatically survive to the next generation.

• Crossover children are created by combining the vectors of a pair of parents.

• Mutation children are created by introducing random changes, or mutations, to a single parent.

• Generations — The algorithm stops when the number of generations reaches the value of Generations.

• Time limit — The algorithm stops after running for an amount of time in seconds equal to Time limit.

• Fitness limit — The algorithm stops when the value of the fitness function for the best point in the current population is less than or equal to Fitness limit.

• Stall generations — The algorithm stops when the average relative change in the fitness function value over Stall generations is less than Function tolerance.

• Stall time limit — The algorithm stops if there is no improvement in the objective function during an interval of time in seconds equal to Stall time limit.

• In the first step, the function selects parents deterministically according to the integer part of the scaled value for each individual. For example, if an individual's scaled value is 2.3, the function selects that individual twice as a parent.

• In the second step, the selection function selects additional parents using the fractional parts of the scaled values, as in stochastic uniform selection. The function lays out a line in sections, whose lengths are proportional to the fractional part of the scaled value of the individuals, and moves along the line in equal steps to select the parents.

• Elite count — The number of individuals with the best fitness values in the current generation that are guaranteed to survive to the next generation. These individuals are called elite children. The default value of Elite count is 2.

  When Elite count is at least 1, the best fitness value can only decrease from one generation to the next. This is what we want to happen, since the genetic algorithm minimizes the fitness function. Setting Elite count to a high value causes the fittest individuals to dominate the population, which can make the search less effective.

• Crossover fraction — The fraction of individuals in the next generation, other than elite children, that are created by crossover. Setting the crossover function describes how the value of Crossover fraction affects the performance of the genetic algorithm.

• Crossover children by selecting vector entries, or genes, from a pair of individuals in the current generation and combines them to form a child.

• Mutation children by applying random changes to a single individual in the current generation to create a child.

• Elite count, in Reproduction options, specifies the number of elite children.

• Crossover fraction, in Reproduction options, specifies the fraction of the population, other than elite children, that are crossover children.

• There are two elite children.

• There are 18 individuals other than elite children, so the algorithm rounds 0.8*18 = 14.4 to 14 to get the number of crossover children.

• The remaining four individuals, other than elite children, are mutation children.

Syntax used in GA:

x = ga(fun,nvars) finds a local unconstrained minimum, x, to the objective function, fun. nvars is the dimension (number of design variables) of fun.

x = ga(fun,nvars,A,b) finds a local minimum x to fun, subject to the linear inequalities A*x ≤ b. ga evaluates the matrix product A*x as if x is transposed (A*x').

x = ga(fun,nvars,A,b,Aeq,beq) finds a local minimum x to fun, subject to the linear equalities Aeq*x = beq and A*x ≤ b. (Set A=[] and b=[] if no linear inequalities exist.)

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub,nonlcon) subjects the minimization to the constraints defined in nonlcon. The function nonlcon accepts x and returns vectors C and Ceq, representing the nonlinear inequalities and equalities respectively. ga minimizes the fun such that C(x) ≤ 0 and Ceq(x) = 0. (Set lb=[] and ub=[] if no bounds exist.)

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub,nonlcon,options) minimizes with the default optimization parameters replaced by values in options. (Set nonlcon=[] if no nonlinear constraints exist.) Create options using optimoptions.

A MATLAB code has been generated which shows how the Genetic Algorithm works:

clear all
close all
clc

x = linspace(0,0.6,150);
y = linspace(0,0.6,150);

%Convering 1D array to 2D array
[xx yy] = meshgrid(x,y)
num_cases = 50;

tic;
for i = 1:length(xx)
    for j = 1:length(yy)
        input_vector(1) = xx(i,j)
        input_vector(2) = yy(i,j)
        f(i,j) = stalagmite(input_vector)
    end
end
study_time = toc       %For calculating time taken for this study
surfc(xx,yy,-f)
shading interp
xlabel('x value')
ylabel('y value')
title('Stalagmite Function')

%study_1
tic 
for i = 1:num_cases
    [inputs,fopt(i)] = ga(@stalagmite,2);
    xopt(i) = inputs(1);
    yopt(i) = inputs(2);
end
study_1time = toc

figure(1)
subplot(2,1,1)
hold on
surfc(x,y,-f)
shading interp 
plot3(xopt,yopt,-fopt,'marker','o','markersize',5,'markerfacecolor','r')
title('Unbounded inputs')
subplot(2,1,2)
plot(-fopt)
xlabel('Iterations')
ylabel('Function Maximum')

%study_2
tic
for i = 1:num_cases
    [inputs,fopt(i)] = ga(@stalagmite,2,[],[],[],[],[0;0],[0.6;0.6]);
    xopt(i) = inputs(1);
    yopt(i) = inputs(2);
end
study_2time = toc

figure(2)
subplot(2,1,1)
hold on
surfc(x,y,-f)
shading interp
plot3(xopt,yopt,-fopt,'marker','o','markersize',5,'markerfacecolor','r');
title('Optimum solution')
subplot(2,1,2)
plot(-fopt)
xlabel('iterations')
ylabel('Function maximum')

%study_3
options = optimoptions(@ga)
options = optimoptions(options,'populationsize',170);

tic
for i = 1:num_cases
    [inputs,fopt(i)] = ga(@stalagmite,2,[],[],[],[],[0;0],[1;1],[],[],options);
    xopt(i) = inputs(1)
    yopt(i) = inputs(2)
end
study_3time = toc

figure(3)
subplot(2,1,1)
hold on
surfc(x,y,-f)
shading interp
plot3(xopt,yopt,-fopt,'marker','o','markersize',5,'markerfacecolor','r');
title('Optimum solution')
subplot(2,1,2)
plot(-fopt)
xlabel('iterations')
ylabel('Function maximum')

Global_Maxima = -fopt
​

Function for Stalagmite:

function [f] = stalagmite(input_vector)
x = input_vector(1);
y = input_vector(2);

f1 = (sin(5.1*pi*x + 0.5)).^6;
f2 = exp(-4*log(2)*((x - 0.0667).^2)./0.64);
f3 = (sin(5.1*pi*y + 0.5)).^6;
f4 = exp(-4*log(2)*((y - 0.0667).^2)./0.64);

f = -(f1*f2*f3*f4)
end

Result Report:

Study_2:

Study_3: