Apply Runic formatting to benchmark/ and examples/

The fredrikekre/runic-action checks the whole repo, not just src/test/,
so the previous formatting commit missed benchmark/benchmarks.jl and
the example scripts. Format them in-place to make FormatCheck.yml
pass cleanly.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

benchmark/benchmarks.jl

@@ -6,9 +6,9 @@ Random.seed!(2);
 rosenbrock(x) = (1.0 - x[1])^2 + 100.0 * (x[2] - x[1]^2)^2
 
 N = 3
-cmaes = CMAES(;mu=20, lambda=100)
-ga = GA(populationSize=100, ɛ=0.1, selection=rouletteinv, crossover=intermediate(0.25), mutation=domainrange(fill(0.5,N)))
-es = ES(initStrategy=IsotropicStrategy(N), recombination=average, srecombination=average, mutation=gaussian, smutation=gaussian, μ=10, ρ=3, λ=100, selection=:plus)
+cmaes = CMAES(; mu = 20, lambda = 100)
+ga = GA(populationSize = 100, ɛ = 0.1, selection = rouletteinv, crossover = intermediate(0.25), mutation = domainrange(fill(0.5, N)))
+es = ES(initStrategy = IsotropicStrategy(N), recombination = average, srecombination = average, mutation = gaussian, smutation = gaussian, μ = 10, ρ = 3, λ = 100, selection = :plus)
 de = DE(populationSize = 100)
 
 suite = BenchmarkGroup()

examples/120bits.jl

@@ -17,7 +17,7 @@ using Evolutionary, Test, Random
 function fitness(oset, bsize = 6)
     scores = Dict(i => (i != bsize ? 3i : 20) for i in 0:bsize)
     # count 1s in blocks
-    ht = Dict{Int,Int}()
+    ht = Dict{Int, Int}()
     sl = sr = 0
     for i in oset
         if i > 60
@@ -43,34 +43,35 @@ function fitness(oset, bsize = 6)
             error("Problem")
         end
         ss += scores[cnt]
-        if (cnt == 1) && ((blk+1)*bsize in oset)
+        if (cnt == 1) && ((blk + 1) * bsize in oset)
             ss += 9
         end
         #println("$blk, $cnt, $(scores[cnt]), $ss")
     end
     ss -= 2(sl > 13 ? sl : 0)
     ss -= 2(sr > 13 ? sr : 0)
-    ss
+    return ss
 end
 
-# Bit string examples 
+# Bit string examples
 bstr = "000100 001010 000010 111111 000100 101000 000010 000000 000001 000000 000010 000001 001000 000000 000000 010000 000000 000010 000000 000000"
-idxs = [i for (i,j) in enumerate(filter(c->c != ' ', bstr)) if j == '1']
+idxs = [i for (i, j) in enumerate(filter(c -> c != ' ', bstr)) if j == '1']
 @test fitness(idxs) == 50
 
 # optimal solution
-idxs_opt = [6*i for i in 1:20]
+idxs_opt = [6 * i for i in 1:20]
 @test fitness(idxs_opt) == 240
 
 # GA solution
-mthd = GA(populationSize = 100, selection = tournament(5),
-          crossover = SSX, crossoverRate = 0.99,
-          mutation  = replace(collect(1:120)), mutationRate = 0.1)
+mthd = GA(
+    populationSize = 100, selection = tournament(5),
+    crossover = SSX, crossoverRate = 0.99,
+    mutation = replace(collect(1:120)), mutationRate = 0.1
+)
 
 Random.seed!(42)
-opts = Evolutionary.Options(show_trace=false, successive_f_tol=30)
-init_pop = ()->randperm(120)[1:20]
-res = Evolutionary.optimize(idxs->-fitness(idxs), init_pop, mthd, opts)
+opts = Evolutionary.Options(show_trace = false, successive_f_tol = 30)
+init_pop = () -> randperm(120)[1:20]
+res = Evolutionary.optimize(idxs -> -fitness(idxs), init_pop, mthd, opts)
 println(res)
 Evolutionary.minimizer(res) |> sort
-

examples/beam.jl

@@ -3,39 +3,39 @@
 
 using Evolutionary, Test, Random
 
-beam(x) = 1.10471*x[2]*x[1]^2+0.04811*x[3]*x[4]*(14+x[2])
+beam(x) = 1.10471 * x[2] * x[1]^2 + 0.04811 * x[3] * x[4] * (14 + x[2])
 lx = [0.125, 0.1, 0.1, 0.125]
 ux = [5.0, 10.0, 10.0, 5.0]
 
-P = 6000; L = 14; E = 30e+6; G = 12e+6;
+P = 6000; L = 14; E = 30.0e+6; G = 12.0e+6;
 τₘₐₓ = 13600; σₘₐₓ = 30000; δₘₐₓ = 0.25;
-M(x) = P*(L+x[2]/2)
-R(x) = sqrt(0.25*(x[2]^2+(x[1]+x[3])^2))
-J(x) = 2/sqrt(2)*x[1]*x[2]*(x[2]^2/12+0.25*(x[1]+x[3])^2)
-P_c(x) = (4.013*E/(6*L^2))*x[3]*x[4]^3*(1-0.25*x[3]*sqrt(E/G)/L)
-τ₁(x) = P/(sqrt(2)*x[1]*x[2])
-τ₂(x) = M(x)*R(x)/J(x)
-τ(x) = sqrt(τ₁(x)^2+τ₁(x)*τ₂(x)*x[2]/R(x)+τ₂(x)^2)
-σ(x) = 6*P*L/(x[4]*x[3]^2)
-δ(x) = 4*P*L^3/(E*x[4]*x[3]^3)
-
-con_c1(x) = [τ(x), σ(x), x[4]-x[1], 0.10471*x[1]^2+0.04811*x[3]*x[4]*(14.0+x[2]), P_c(x), δ(x)]
-lc = [-Inf, -Inf, 0.0, -Inf,   P, -Inf]
-uc = [τₘₐₓ, σₘₐₓ, Inf,  5.0, Inf, δₘₐₓ]
-
-con_c2(x) = [τ(x)-τₘₐₓ, σ(x)-σₘₐₓ, x[1]-x[4], 0.10471*x[1]^2+0.04811*x[3]*x[4]*(14.0+x[2])-5.0, P-P_c(x), δ(x)-δₘₐₓ]
+M(x) = P * (L + x[2] / 2)
+R(x) = sqrt(0.25 * (x[2]^2 + (x[1] + x[3])^2))
+J(x) = 2 / sqrt(2) * x[1] * x[2] * (x[2]^2 / 12 + 0.25 * (x[1] + x[3])^2)
+P_c(x) = (4.013 * E / (6 * L^2)) * x[3] * x[4]^3 * (1 - 0.25 * x[3] * sqrt(E / G) / L)
+τ₁(x) = P / (sqrt(2) * x[1] * x[2])
+τ₂(x) = M(x) * R(x) / J(x)
+τ(x) = sqrt(τ₁(x)^2 + τ₁(x) * τ₂(x) * x[2] / R(x) + τ₂(x)^2)
+σ(x) = 6 * P * L / (x[4] * x[3]^2)
+δ(x) = 4 * P * L^3 / (E * x[4] * x[3]^3)
+
+con_c1(x) = [τ(x), σ(x), x[4] - x[1], 0.10471 * x[1]^2 + 0.04811 * x[3] * x[4] * (14.0 + x[2]), P_c(x), δ(x)]
+lc = [-Inf, -Inf, 0.0, -Inf, P, -Inf]
+uc = [τₘₐₓ, σₘₐₓ, Inf, 5.0, Inf, δₘₐₓ]
+
+con_c2(x) = [τ(x) - τₘₐₓ, σ(x) - σₘₐₓ, x[1] - x[4], 0.10471 * x[1]^2 + 0.04811 * x[3] * x[4] * (14.0 + x[2]) - 5.0, P - P_c(x), δ(x) - δₘₐₓ]
 lc = fill(-Inf, 6)
 uc = fill(0.0, 6)
 
-opts = Evolutionary.Options(iterations=2000, successive_f_tol=40)
-mthd = CMAES(mu = 90, c_mu=0.3)
-mthd = GA(populationSize = 120, ɛ = 0.03, crossoverRate=0.8, mutationRate=0.01, selection=rouletteinv, crossover=LX(0.0,4.0), mutation = PM(lx,ux,1.0))
-mthd = DE(n=2)
+opts = Evolutionary.Options(iterations = 2000, successive_f_tol = 40)
+mthd = CMAES(mu = 90, c_mu = 0.3)
+mthd = GA(populationSize = 120, ɛ = 0.03, crossoverRate = 0.8, mutationRate = 0.01, selection = rouletteinv, crossover = LX(0.0, 4.0), mutation = PM(lx, ux, 1.0))
+mthd = DE(n = 2)
 
-c = PenaltyConstraints([1e3, 1e3, 1e3, 1e3, 1e2, 1e1, 1e3, 1e1, 1e1, 1e0], lx, ux, lc, uc, con_c1)
-c = PenaltyConstraints([1e3, 1e3, 1e3, 1e3, 1e1, 1e1, 1e3, 1e1, 1e1, 1e0], Evolutionary.ConstraintBounds(lx,ux,lc,[]), con_c2)
-c = WorstFitnessConstraints(Evolutionary.ConstraintBounds(lx,ux,lc,uc), con_c1)
-c = WorstFitnessConstraints(Evolutionary.ConstraintBounds(lx,ux,lc,uc), con_c2)
+c = PenaltyConstraints([1.0e3, 1.0e3, 1.0e3, 1.0e3, 1.0e2, 1.0e1, 1.0e3, 1.0e1, 1.0e1, 1.0e0], lx, ux, lc, uc, con_c1)
+c = PenaltyConstraints([1.0e3, 1.0e3, 1.0e3, 1.0e3, 1.0e1, 1.0e1, 1.0e3, 1.0e1, 1.0e1, 1.0e0], Evolutionary.ConstraintBounds(lx, ux, lc, []), con_c2)
+c = WorstFitnessConstraints(Evolutionary.ConstraintBounds(lx, ux, lc, uc), con_c1)
+c = WorstFitnessConstraints(Evolutionary.ConstraintBounds(lx, ux, lc, uc), con_c2)
 
 Random.seed!(0);
 result = Evolutionary.optimize(beam, c, mthd, opts)

examples/mixedint.jl

@@ -5,45 +5,45 @@
 
 using Evolutionary, Test, Random
 
-f1(x) = 2*x[1]+x[2]
+f1(x) = 2 * x[1] + x[2]
 lx = [0.0, 0]
 ux = [1.6, 1]
 
-cons(x) = [1.25-x[1]^2-x[2], x[1]+x[2]]
+cons(x) = [1.25 - x[1]^2 - x[2], x[1] + x[2]]
 lc = [-Inf, -Inf]
 uc = [0.0, 1.6]
 
 tc = [Float64, Int]
 
-cb = Evolutionary.ConstraintBounds(lx,ux,lc,uc)
-c = MixedTypePenaltyConstraints(PenaltyConstraints(1e3, cb, cons), tc)
+cb = Evolutionary.ConstraintBounds(lx, ux, lc, uc)
+c = MixedTypePenaltyConstraints(PenaltyConstraints(1.0e3, cb, cons), tc)
 c = MixedTypePenaltyConstraints(WorstFitnessConstraints(cb, cons), tc)
-init = ()->Real[rand(Float64), rand(0:1)]
+init = () -> Real[rand(Float64), rand(0:1)]
 
-opts = Evolutionary.Options(iterations=500, abstol=1e-5)
-mthd = GA(populationSize=40, crossoverRate=0.8, mutationRate=0.05, selection=susinv, crossover=MILX(), mutation=MIPM(lx,ux))
+opts = Evolutionary.Options(iterations = 500, abstol = 1.0e-5)
+mthd = GA(populationSize = 40, crossoverRate = 0.8, mutationRate = 0.05, selection = susinv, crossover = MILX(), mutation = MIPM(lx, ux))
 
 Random.seed!(10);
 result = Evolutionary.optimize(f1, c, init, mthd, opts)
-@test minimum(result) ≈ 2.0 atol=1e-1
-@test Evolutionary.minimizer(result) ≈ [0.5, 1] atol=1e-1
+@test minimum(result) ≈ 2.0 atol = 1.0e-1
+@test Evolutionary.minimizer(result) ≈ [0.5, 1] atol = 1.0e-1
 
 #-----------------------------------------------------------------
 
-f8(z) = sum((z[4:end-1].-1).^2) - log(z[end]+1) + sum((z[i]-i)^2 for i in 1:3)
+f8(z) = sum((z[4:(end - 1)] .- 1) .^ 2) - log(z[end] + 1) + sum((z[i] - i)^2 for i in 1:3)
 
-@test f8(Real[0.2, 1.280624, 1.954483, 1, 0, 0, 1]) ≈ 3.55746 atol=1e-6
+@test f8(Real[0.2, 1.280624, 1.954483, 1, 0, 0, 1]) ≈ 3.55746 atol = 1.0e-6
 
 cons(z) = [
-    sum(z[1:end-1]),
-    sum(v->v^2, z[[1,2,3,6]]),
-    z[1]+z[4],
-    z[2]+z[5],
-    z[3]+z[6],
-    z[1]+z[7],
-    z[2]^2+z[5]^2,
-    z[3]^2+z[6]^2,
-    z[2]^2+z[6]^2,
+    sum(z[1:(end - 1)]),
+    sum(v -> v^2, z[[1, 2, 3, 6]]),
+    z[1] + z[4],
+    z[2] + z[5],
+    z[3] + z[6],
+    z[1] + z[7],
+    z[2]^2 + z[5]^2,
+    z[3]^2 + z[6]^2,
+    z[2]^2 + z[6]^2,
 ]
 
 lx = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
@@ -54,13 +54,13 @@ uc = [5.0, 5.5, 1.2, 1.8, 2.5, 1.2, 1.64, 4.25, 4.64]
 
 tc = [Float64, Float64, Float64, Int, Int, Int, Int]
 
-cb = Evolutionary.ConstraintBounds(lx,ux,lc,uc)
+cb = Evolutionary.ConstraintBounds(lx, ux, lc, uc)
 # c = MixedTypePenaltyConstraints(PenaltyConstraints(1e2, cb, cons), tc)
 c = MixedTypePenaltyConstraints(WorstFitnessConstraints(cb, cons), tc)
-init = ()->Real[rand(Float64,3); rand(0:1,4)]
+init = () -> Real[rand(Float64, 3); rand(0:1, 4)]
 
-opts = Evolutionary.Options(iterations=2000)
-mthd = GA(populationSize=300, ɛ=0.05, crossoverRate=0.8, mutationRate=0.01, selection=susinv, crossover=MILX(0.0,0.5,0.3), mutation=MIPM(lx,ux))
+opts = Evolutionary.Options(iterations = 2000)
+mthd = GA(populationSize = 300, ɛ = 0.05, crossoverRate = 0.8, mutationRate = 0.01, selection = susinv, crossover = MILX(0.0, 0.5, 0.3), mutation = MIPM(lx, ux))
 
 Random.seed!(544);
 result = Evolutionary.optimize(f8, c, init, mthd, opts)