4/19/2019 hydroPSO source: R/PSO_v2013.

# Parte do pacote hydroPSO, http://www.rforge.net/hydroPSO/

# Copyright 2008-2018 Mauricio Zambrano-Bigiarini
# Distribuído sob a GPL 2 ou posterior

################################################## ################################
Random.Bounded.Matrix ##
########### ################################################## ###################
# Autor: Mauricio Zambrano-Bigiarini ##
###################### ################################################## ########
# Criado: 2008 ##
# Atualizações: 23-Nov-2010 ##
# 20-Sep-2012; 29-out-2012 ##
##################### #####################################
# Propósito: Criar uma matriz gerada aleatoriamente, com uma distribuição uniforme limitada

# 'npart': número de partículas no enxame

# 'X.MinMax': Matriz de 'n' linhas e 2 colunas,
# a primeira coluna tem os valores mínimos para cada dimensão e
# a segunda coluna tem os valores máximos para cada dimensão
Random.Bounded.Matrix <- function ( npart , x.MinMax ) {

# dimensão do espaço da solução (número de parâmetros)

n <- nrow ( x.MinMax )

menor <- matriz ( rep ( x.MinMax [, 1 ], npara ), nrow = npart , byrow = TRUE )
superior <- matriz ( rep ( x.MinMax [, 2 ], npart ), nrow = npart , byrow = VERDADEIRO )

# inicialização aleatória para todas as partículas, com um valor em [0,1]

X <- matriz ( runif ( n * npart , min = 0 , máx = 1 ), nrow = npart , ncol = n )

# Transformando X no intervalo real definido pelo usuário

#X <- t (inferior + (superior - inferior) * t (X)) # ao usar vetor em vez de matrizes
X <- inferior + ( superior - inferior ) * X

} # 'Random.Bounded.Matrix' end
# set.seed (1)
# Random.Bounded.Matrix (10, x.MinMax)

################################################## ##############################
## Amostragem aleatória em latim-hipercubo ##
########### ################################################## ###################
# Autor: Mauricio Zambrano-Bigiarini ##
# Criado: 17-Dez-2010 ##
# Atualizações: 20-Set-2012; 29-out-2012 ##
# 07-fev-2014 ##
################################### ##############################################
Propósito: Desenha um Amostra Latin Hypercube de um conjunto de distribuições uniformes
# para uso na criação de um projeto de hipercubo em latim
################## ##################################### ########################################
Output: Uma matriz de Amostra Hipercubo Latina de ndim com valores uniformemente
# distribuídos em 'ranges'
######################################### #######################################

# 'n': número de estratos usados para dividir cada intervalo de parâmetros.

# Para hydroPSO: 'n = npart'
# 'ranges': Matriz de 'N' linhas e 2 colunas, (N é o número de parâmetros)
# a primeira coluna tem os valores mínimos para cada dimensão e
# a segunda coluna tem os valores máximos para cada dimensão
rLHS <- function ( n , ranges ) {

# dimensão do espaço da solução (número de parâmetros)

ndim <- nrow ( ranges )

https://rdrr.io/cran/hydroPSO/src/R/PSO_v2013.R 1/5
4/19/2019 hydroPSO source: R/PSO_v2013.R

# número de partículas
npart <- n

menor <- matriz ( rep ( intervalos [, 1 ], npara ), nrow = npart , byrow = TRUE )
superior <- matriz ( rep ( intervalos [, 2 ], npart ), nrow = npart , byrow = TRUE )

# Inicialização de LHS para todas as partículas, com um valor em [0,1]

X <- randomLHS ( n , ndim ) # lhs :: randomLHS

# Transformando X no intervalo real definido pelo usuário

#X <- t (inferior + (superior - inferior) * t (X)) # ao usar vetor em vez de matrizes
X <- inferior + ( superior - inferior ) * X

} # 'rLHS' end

################################################## ###############################
enorm #
################# ################################################## #############
# Autor: Mauricio Zambrano-Bigiarini
############################# ################################################## #
# Criado: 19-Sep-2012 #
# Atualizações: #
#################################### #############################################
Propósito: Calcula o Euclidiano norma de um vetor #
################################################## ###############################
Saída: valor numérico único com a norma euclideana de 'x' #
##### ################################################## #########################
enorm <- function ( x ) sqrt ( soma ( x * x ) )

################################################## ##############################
# alea.normal #
############### ################################################## ###############
# Autor: Mauricio Zambrano-Bigiarini #
# Baseado na função Matlab desenvolvida por Maurice Clerc (Maio de 2011), #
# e disponível em: #
# http: // www.particleswarm.info/SPSO2011_matlab.zip
######################################### #########################################
Criado em: 19-Set-2012 #
# Atualizações: 29-out-2012
################### ########################################
Propósito: Utiliza a forma polar da Caixa Transformação -Muller para obter #
# um número pseudo-aleatório de uma distribuição Gaussiana #
################################# ################################################
Saída: valor numérico único com um número pseudo-aleatório de uma distribuição #
#
gaussiana com média = 'média' e desvio padrão = 'sd' # #####################
################################################## #########
alea.normal <- function ( mean =0 , sd = 1 ) {

w <- 2
enquanto ( w > = 1 ) {
x1 <- 2 * runif ( 1 ) - 1
x2 <- 2 * runif ( 1 ) - 1
w <- x1 * x1 + x2 * x2
} # 'ENQUANTO' fim
w <- sqrt ( -2 * log ( w ) / w )
y1 <- x1 * w
if ( runif ( 1 ) < 0.5 ) y1 <- - y1
y1 <- y1 * sd + média

} # 'alea.normal' end

https://rdrr.io/cran/hydroPSO/src/R/PSO_v2013.R 2/5
4/19/2019 hydroPSO source: R/PSO_v2013.R

################################################## ##############################
# alea.sphere
############### ################################################## ###############
# Autor: Mauricio Zambrano-Bigiarini #
# Baseado na função Matlab desenvolvida por Maurice Clerc (Maio de 2011), #
# e disponível em: #
# http: // www.particleswarm.info/SPSO2011_matlab.zip
######################################### #########################################
Criado em: 19-Set-2012 #
# Atualizações: #
####################### ###################################
Propósito: Gera um ponto aleatório dentro da hiperesfera centrada #
# em torno de G com raio = r #
###################### ####################################
Output: vetor numérico com a localização de um ponto aleatório dentro do #
# hypersphere around G com radius = r #
######################################### #######################################
alea.sphere <- função ( G ,raio ) {

# dimensão de 'G' (número de parâmetros)

n <- comprimento ( G )

# Passo 1. Direção
l <- 0
#x <- replicar (n, alea.normal (média = 0, sd = 1))
x <- rnorm ( n , média = 0 , sd = 1 )
l <- sqrt ( soma ( x * x ) )

# Etapa 2. Random Rius

r <- runif ( 1 )

x <- r * raio * x / l

# Centralizando o ponto aleatório no

retorno 'G' ( x + G )

} # 'alea.sphere' end

################################################## ###############################
compute.CF Função #
############## ################################################## ################
# Autor: Mauricio Zambrano-Bigiarini
########################### ################################################## ####
# Criado: 2008 #
# Atualizações: #
##################################### ###########################################
# Calcula o fator de constrição de Clerc
# Clerc, M; Kennedy, J .; , "O enxame de partículas - explosão, estabilidade e
# convergência em um espaço complexo multidimensional", Evolutionary Computation,
# IEEE Transactions on, vol.6, no.1, pp. 58-73, fev 2002
# doi: 10.1109 / 4235.985692

compute.CF <- função ( c1 , c2 ) {

psi <- c1 + c2 # psi> = 4
CF <- 2 / abs ( 2 - psi - sqrt ( psi ^ 2 - 4 * psi ) )
} # 'compute. Final da CF

# 'x': vetor de 'n' parâmetros, correspondentes a uma partícula

# 'v': vetor de 'n' velocidades de cada parâmetro, correspondente à partícula atual
# 'vmax.perc': porcentagem da faixa de cada dimensão isto é permitido como
# velocidade máxima nessa dimensão
https://rdrr.io/cran/hydroPSO/src/R/PSO_v2013.R 3/5
4/19/2019 hydroPSO source: R/PSO_v2013.R
# 'Pbest': matriz com os melhores valores de parâmetros atuais para todas as partículas
# 'gbest': vetor com os melhores valores de parâmetros no enxame
# 'w': Fator de inércia.
# 'c1': constante que incentiva a exploração do espaço da solução
# 'c2': constante que incentiva a exploração do melhor ambiente global atual
# 'CF': constante representando o Fator de Constrição do Clerk, para assegurar a convergência do
algoritmo PSO
# 'x.MinMax': Matriz com o intervalo válido para cada parâmetro de 'X'.
# Rows = 'n' (número do parâmetro
# Columns = 2,
# A primeira coluna tem o valor mínimo possível para cada parâmetro
# A segunda coluna tem o valor máximo possível para cada parâmetro
# 'topology': character, com a topologia a ser usada no PSO.Os valores válidos
# estão em c ('gbest', 'lbest')
# 'method': character, com o método a ser usado como algoritmo
PSO.Valores válidos # estão em c ('spso2007', 'spso2011',

# Resultado: vetor de 'n' velocidades, uma para cada parâmetro, correspondendo à partícula atual
############################## ##################################################
## compute.veloc Function ##
################### ######################################
# Autor: Mauricio Zambrano-Bigiarini #
#### ################################################## ##########################
# Criado: 2008 #
# Atualizações: out-2011; Nov-2011 #
# 19-set-2012; 20 de setembro de 2012; 28 de outubro de 2012; 31 de outubro de 2012
# 09-May-2016 #
#################### #####################################
compute.veloc <- function ( x , v , w , c1 , c2 , CF , Pbest , part.index , gbest ,
topologia , método , MinMax , neighs.index ,
localBest , localBest.pos ,
ngbest.fit , ngbest , lpbest.fit ) {

pbest <- Pbest [ part.index , ]

# dimensão de 'x' (número de parâmetros)

n <- comprimento ( gbest )

r1 <- runif ( n , min = 0 , máx = 1 )

r2 <- runif ( n , min = 0 , max = 1 )

if ( método == "spso2011" ) {

p <- x + r1 * c1 * ( pbest - x )
l <- x + r2 * c2 * ( localBest - x )

if ( part.index ! = localBest.pos ) {
Gr <- ( x + p + l ) / 3
} mais Gr <- ( x + p ) / 2

vn <- CF * ( w * v + alea.sphere ( G = Gr , raio = enorm ( Gr - x ) ) - x )

} else if ( método == "spso2007" ) {

if ( part.index ! = localBest.pos ) {
vn <- CF * ( w * v + r1 * c1 * ( pbest - x ) + r2 * c2 * ( localBest - x ) )
} mais vn <- CF * ( w * v + r1 * c1 * ( pbest - x) )

} else if ( método == "ipso" ) {

# número de melhores partículas que devem ser consideradas

nngbest <- length ( ngbest.fit )

R2 <- matriz ( rep ( r2 , nngbest ), nrow = nngbest , byrow = TRUE )

https://rdrr.io/cran/hydroPSO/src/R/PSO_v2013.R 4/5
4/19/2019 hydroPSO source: R/PSO_v2013.R
# computando os valores c2 para cada uma das melhores partículas,
# ponderada de acordo com seu valor de adequação
se ( MinMax == "min" ) {
c2i <- c2 * ( ( 1 / ngbest.fit ) / soma ( 1 / ngbest. fit ) )
} else c2i <- c2 * ( ngbest.fit / sum ( ngbest.fit ) )

nan.index <- which ( is.nan ( c2i ))

if ( tamanho ( nan.index ) > 0 ) c2i [ nan.index ] <- c2

# transformando 'x' em uma matriz, com os mesmos valores em cada linha, em

# ordem para poder subtrair 'x' do 'ninho'
X <- matriz ( rep ( x , nngbest ), ncol = n , byrow = VERDADEIRO )

# computando a velocidade
vn <- CF * ( w * v + r1 * c1 * ( pbest - x ) + colSums ( R2 * c2i * ( ngbest - X )
) )

} else if ( método == "fips" ) {

neighs.index <- neighs.index [ ! is.na ( neighs.index )] # apenas para

topologia == 'aleatório'
N <- comprimento ( neighs.index )
X <- matriz ( rep ( x , N ), nevo = N , byrow = VERDADEIRO )
P <- Pbest [ neighs.index , ]
phi<- c1 + c2
r <- runif ( N , min = 0 , max = phi )

vn <- CF * ( w * v + ( 1 / N ) * colSums ( r * ( P - X ) ) )

} else if ( método == "wfips" ) {

neighs.index <- neighs.index [ ! is.na ( neighs.index )] # apenas para

topologia == 'aleatório'
N <- comprimento ( neighs.index )
X <- matriz ( rep ( x , N ), nevo = N , byrow = VERDADEIRO )
P <- Pbest [ neighs.index , ]
pfit <- lpbest.fit [ neighs.index ]
phi <- c1 + c2
r <- runif ( N , min = 0 , max = phi )
se ( MinMax == "min" ) {
peso <- ( 1 / pfit ) / soma ( 1 / pfit )
} mais peso <- pfit / soma ( pfit )

vn <- CF * ( w * v + ( 1 / N ) * colSums ( wght * r * ( P - X ) ) )

} else if ( método == "canonico" )

vn <- CF * ( w * v + r1 * c1 * ( pbest - x ) + r2 * c2 * ( localBest -

x ) )

retorno ( vn )

} # 'compute.veloc' end

https://rdrr.io/cran/hydroPSO/src/R/PSO_v2013.R 5/5