Optimizing Sensor Ontology Alignment through Compact co-Firefly Algorithm

. 2020 Apr 6;20(7):2056. doi: 10.3390/s20072056

Algorithm 3 Compact co-Firefly Algorithm

** Initialization **

$g e n e r a t i o n = 0$ ;

Initialize $P V_{b e t t e r}$ and $P V_{w o r s e}$ by setting all the probabilities inside as 0.5;

generate $e l i t e_{b e t t e r}$ and $e l i t e_{w o r s e}$ through $P V_{b e t t e r}$ and $P V_{w o r s e}$ , respectively;

** Evolving Process **

while $g e n e r a t i o n < m a x G e n$ do

** Exploitation **

generate a solution $i n d_{n e w}$ through $P V_{b e t t e r}$ ;

$i n d_{n e w}$ = $a l p h a$ -step( $i n d_{n e w}$ ); // see also Algorithm 1

** Competition **

$c o m p e t e (e l i t e_{b e t t e r}, i n d_{n e w})$ ;

if $w i n n e r = = i n d_{n e w}$ then

$e l i t e_{b e t t e r} = i n d_{n e w}$ ;

end if

** PV Update **

for $i = 0$ ; $i < P V_{b e t t e r} . l e n g t h$ ; i++ do

if $w i n n e r [i] = = 1$ then

$P V_{b e t t e r} {[i]}_{b e t t e r} = P V_{b e t t e r} [i] + s t e p$ ;

else

$P V_{b e t t e r} [i] = P V_{b e t t e r} [i] - s t e p$ ;

end if

end for

** Exploration **

generate a solution $i n d_{n e w}$ through $P V_{w o r s e}$ ;

$i n d_{n e w}$ = $b e t a$ -step( $i n d_{n e w}$ , $i n d_{w o r s e}$ ); // see also Algorithm 2

** Competition **

$c o m p e t e (e l i t e_{w o r s e}, i n d_{n e w})$ ;

if $w i n n e r = = i n d_{n e w}$ then

swap( $e l i t e_{w o r s e}, i n d_{n e w})$ ;

end if

** PV Update **

for $i = 0$ ; $i < P V_{w o r s e} . l e n g t h$ ; i++ do

if $w i n n e r [i] = = 1$ then

$P V_{w o r s e} [i] = P V_{w o r s e} [i] + s t e p$ ;

else

$P V_{w o r s e} [i] = P V_{w o r s e} [i] - s t e p$ ;

end if

end for

** Communication **

$c o m p e t e (e l i t e_{b e t t e r}, e l i t e_{w o r s e})$ ;

if $w i n n e r = = e l i t e_{w o r s e}$ then

swap( $e l i t e_{b e t t e r}, e l i t e_{w o r s e})$ ;

swap( $P V_{b e t t e r}, P V_{w o r s e})$ ;

end if

update $P V_{w o r s e}$ ; // see also Section 4.2.2

** Judge whether the algorithm converges **

if all elements of $P V_{b e t t e r}$ and $P V_{w o r s e}$ are equal to 1 or 0 then

break;

end if

end while

output $e l i t e_{b e t t e r}$ ;