Algoritmo Vagalumes

function fa_ndim
% parametros [n N_iteration alpha betamin gamma]
para=[20 100 0.5 0.2 1];
help fa_ndim.m
% limites de procura e dimenses
d=1;
Lb=zeros(1,d);
Ub=2*ones(1,d);
% Aleatoriedade Inicial
u0=Lb+(Ub-Lb).*rand(1,d);
[u,fval,NumEval]=ffa_mincon(@cost,u0,Lb,Ub,para);
% Resultados a ser mostrados
melhorsolucao=u
%numero_total_de_avaliacoes_da_funcao=NumEval

%% Funo Objetivo
function resultado = cost(k,dado)
dado = load ('dado_experimental.csv');
% define as equacoes do modelo
Tamb = 26.5;
f = @(t,T)(-k*(T - Tamb));
% define os parametros da simulacao
ti = 0;
% tempo inicial
tf = 240;
% tempo final
Ti = 90;
% temperatura inicial
% define os parametros do metodo numerico
dt = 0.5;
% passo de integracao
n = (tf-ti)/dt; % numero de passos de integracao
t = zeros(n+1,1); % valores de x
T = zeros(n+1,1); % valores de y
t(1) = ti;
% valor inicial de x
T(1) = Ti;
% valor inicial da funcao
% obter as solucoes numericas
for i = 1:n
t(i+1) = t(i) + dt;
k1 = dt * f(t(i),T(i));
k2 = dt * f(t(i) + dt/2, T(i) + k1/2);
k3 = dt * f(t(i) + dt/2, T(i) + k2/2);
k4 = dt * f(t(i) + dt,T(i) + k3);
T(i+1) = T(i) + (k1 + 2*k2 + 2*k3 + k4)/6;
end
resultado = mean(abs(T-dado(:,2)));

% Inicio do Algoritmo
function [nbest,fbest,NumEval]...
=ffa_mincon(fhandle,u0, Lb, Ub, para)
% Parametros de checagem
if nargin<5, para=[20 100 0.25 0.20 1]; end

if nargin<4, Ub=[]; end

if nargin<3, Lb=[]; end
if nargin<2,
disp('uso: FA_mincon(@cost,u0,Lb,Ub,para)');
end
% n=numero de vagalumes
% MaxGeneration=numero de geraes/passos
% -----------------------------------------------% alpha=0.25;
% aleatoriedade 0--1
% betamn=0.20;
% valor minimo de beta
% gamma=1;
% Coeficiente de absoro
% -----------------------------------------------n=para(1); MaxGeneration=para(2);
alpha=para(3); betamin=para(4); gamma=para(5);
% Nmero total de avaliaes da funo
NumEval=n*MaxGeneration;
% Verifica se o limite superior e limite inferior so do mesmo tamanho
if length(Lb) ~=length(Ub),
disp('limites simples so improprios!');
return
end
% calcula dimenso
d=length(u0);
% valores iniciais de uma matriz
zn=ones(n,1)*10^100;
% -----------------------------------------------% gera os locais iniciais de n vagalumes
[ns,Lightn]=init_ffa(n,d,Lb,Ub,u0);
% Iteraes de marcha do tempo
for k=1:MaxGeneration,
%%%%% inicio das iteraes
% reduo de alpha
alpha=alpha_new(alpha,MaxGeneration);
% avalia novas solues (para todos n vagalumes)
for i=1:n,
zn(i)=fhandle(ns(i,:));
Lightn(i)=zn(i);
end
% Classificao de vaga-lumes pela sua intensidade de luz / objetivos
[Lightn,Index]=sort(zn);
ns_tmp=ns;
for i=1:n,
ns(i,:)=ns_tmp(Index(i),:);
end
%% Encontra o melhor atual
nso=ns; Lighto=Lightn;
nbest=ns(1,:); Lightbest=Lightn(1);
% somente para saida
fbest=Lightbest;

% Move todos os vaga-lumes para os locais melhores

[ns]=ffa_move(n,d,ns,Lightn,nso,Lighto,nbest,...
Lightbest,alpha,betamin,gamma,Lb,Ub);
end

%%%%% final das iteraes

% ----- subfunes -----------% locais iniciais de n vaga-lumes

function [ns,Lightn]=init_ffa(n,d,Lb,Ub,u0)
% se houver limites,
if length(Lb)>0,
for i=1:n,
ns(i,:)=Lb+(Ub-Lb).*rand(1,d);
end
else
% gerar solues em torno da suposio aleatria
for i=1:n,
ns(i,:)=u0+randn(1,d);
end
end
% valor inicial antes das avaliaes da funo
Lightn=ones(n,1)*10^100;
% Move todos os vaga-lumes em relao aos mais brilhantes
function [ns]=ffa_move(n,d,ns,Lightn,nso,Lighto,...
nbest,Lightbest,alpha,betamin,gamma,Lb,Ub)
% Dimensionamento do sistema
scale=abs(Ub-Lb);
% Atualizando vaga-lumes
for i=1:n,
% O parmetro de atratividade beta=exp(-gamma*r)
for j=1:n,
r=sqrt(sum((ns(i,:)-ns(j,:)).^2));
% movimentos de atualizao
if Lightn(i)>Lighto(j), % Mais brilhante
beta0=1; beta=(beta0-betamin)*exp(-gamma*r.^2)+betamin;
tmpf=alpha.*(rand(1,d)-0.5).*scale;
ns(i,:)=ns(i,:).*(1-beta)+nso(j,:).*beta+tmpf;
end
end % final para j
end % final para i
% Verificar se as solues / locais atualizados esto dentro dos
limites
[ns]=findlimits(n,ns,Lb,Ub);

% reduz a aleatoriedade para aumentar a convergncia,

% No entanto, se reduzir a aleatoriedade muito rapidamente, ento
% pode haver convergncia prematura
function alpha=alpha_new(alpha,NGen)
% alpha_n=alpha_0(1-delta)^NGen=10^(-4);
% alpha_0=0.9

delta=1-(10^(-4)/0.9)^(1/NGen);
alpha=(1-delta)*alpha;
% garante que os vaga-lumes esto dentro dos limites
function [ns]=findlimits(n,ns,Lb,Ub)
for i=1:n,
% aplica o limite inferior
ns_tmp=ns(i,:);
I=ns_tmp<Lb;
ns_tmp(I)=Lb(I);
% aplica o limite superior
J=ns_tmp>Ub;
ns_tmp(J)=Ub(J);
% Atualiza este novo movimento
ns(i,:)=ns_tmp;
end