Particle swarm optimization: Difference between revisions

=={{header|C sharp|C#}}==

{{trans|java}}

 

namespace ParticleSwarmOptimization {

}

}

{{out}}

<pre>Test Function : McCormick

=={{header|C++}}==

{{trans|D}}

#include <functional>

#include <iostream>

state.report("Michalewicz (2D)");

std::cout << "f(2.20, 1.57) : " << michalewicz({ 2.2, 1.57 }) << '\n';

{{out}}

<pre>Test Function : McCormick

=={{header|D}}==

{{trans|Kotlin}}

import std.random;

import std.stdio;

state.report("Michalewicz (2D)");

writefln("f(2.20, 1.57) : %.16f", michalewicz([2.2, 1.57]));

{{out}}

<pre>Test Function : McCormick

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

st.report("Michalewicz (2D)")

fmt.Println("f(2.20, 1.57) :", michalewicz([]float64{2.2, 1.57}))

 

{{out}}

 

=={{header|J}}==

 

pso_init =: verb define

)

 

mccormick =: sin@(+/) + *:@(-/) + 1 + _1.5 2.5 +/@:* ]

 

Iteration: 40

GlobalBestPosition: _0.547399 _1.54698

Apply to Michalewicz Function:

michalewicz =: [: -@(+/) sin * 20 ^~ sin@(pi %~ >:@i.@# * *:) NB. tacit equivalent

Iteration: 30

GlobalBestPosition: 2.20296 1.57083

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.Objects;

import java.util.Random;

System.out.printf("f(2.20, 1.57) : %.15f\n", michalewicz(new double[]{2.20, 1.57}));

}

{{out}}

<pre>Test Function : McCormick

Translation of [[Particle_Swarm_Optimization#J|J]].

 

var nDims= y.min.length;

var pos=[], vel=[], bpos=[], bval=[];

state= repeat(function(y){return pso(mccormick,y)}, 40, state);

 

 

Example displayed result (random numbers are involved so there will be a bit of variance between repeated runs:

 

Iteration: 0

GlobalBestPosition: Infinity

Iteration: 40

GlobalBestPosition: -0.5134004259016365,-1.5512442672625184

 

=={{header|Julia}}==

 

const mcclow = [-1.5, -3.0]

println(optimize(michalewicz, x0, ParticleSwarm(;lower=miclow, upper=micupp, n_particles=npar[2])))

@time optimize(michalewicz, x0, ParticleSwarm(;lower=miclow, upper=micupp, n_particles=npar[2]))

<pre>

Results of Optimization Algorithm

=={{header|Kotlin}}==

{{trans|JavaScript}}

 

import java.util.Random

state.report("Michalewicz (2D)")

println("f(2.20, 1.57) : ${michalewicz(doubleArrayOf(2.2, 1.57))}")

 

Sample output:

=={{header|Nim}}==

{{trans|Kotlin}}

 

type

state = iterate(michalewicz, 30, state)

state.report("Michalewicz (2D)")

 

{{out}}

 

=={{header|ooRexx}}==

* Test for McCormick function

*--------------------------------------------------------------------*/

res=rxcalcsin(x+y,16,'R')+(x-y)**2-1.5*x+2.5*y+1

Return res

{{out}}

<pre>-1.5 -2.5 -1.243197504692072

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

) );

%state = %{pso(\&michalewicz, %state)} for 1 .. 30;

{{out}}

<pre>McCormick

=={{header|Phix}}==

{{trans|Kotlin}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">enum</span> <span style="color: #000000;">OMEGA</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">PHIP</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">PHIG</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

=={{header|Python}}==

{{trans|D}}

import random

 

print "f(2.20, 1.57) : %.16f" % (michalewicz([2.2, 1.57]))

 

{{out}}

<pre>Test Function : McCormick

 

=={{header|Racket}}==

(require racket/list racket/math)

 

(PSO (Michalewitz 5) 1000 30 (box 0) (box pi) #:ω 0.3 #:φ_p 0.3 #:φ_g 0.3 #:> <)

(displayln "Michalewitz 10d [-9.66015]")

{{out}}

 

(formerly Perl 6)

{{trans|J (via Javascript, Kotlin, D, Python)}}

my $d = @(%y{'min'});

my $n = %y{'n'};

} );

%state = pso(&michalewicz, %state) for 1 .. 30;

{{out}}

<pre>McCormick

 

Note that REXX uses decimal floating point, not binary.

numeric digits length( pi() ) - length(.) /*use the number of decimal digs in pi.*/

parse arg x y d #part sDigs . /*obtain optional arguments from the CL*/

pi: pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865; return pi

r2r: return arg(1) // ( pi() * 2) /*normalize radians ───► a unit circle.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

{{trans|Kotlin}}

{{libheader|Wren-dynamic}}

import "/dynamic" for Tuple

 

state = iterate.call(michalewicz, 30, state)

report.call(state, "Michalewicz (2D)")

 

{{out}}