func Test_tri01(tst *testing.T) {
//verbose()
chk.PrintTitle("tri01")
V := [][]float64{
{0.0, 0.0},
{1.0, 0.0},
{1.0, 1.0},
{0.0, 1.0},
{0.5, 0.5},
}
C := [][]int{
{0, 1, 4},
{1, 2, 4},
{2, 3, 4},
{3, 0, 4},
}
if chk.Verbose {
plt.SetForPng(1, 300, 150)
Draw(V, C, nil)
plt.Equal()
plt.AxisRange(-0.1, 1.1, -0.1, 1.1)
plt.Gll("x", "y", "")
plt.SaveD("/tmp/gosl/tri", "tri01.png")
}
}
// PlotTwoVarsContour plots contour for two variables problem. len(x) == 2
// Input
// dirout -- directory to save files
// fnkey -- file name key for eps figure
// x -- solution. can be <nil>
// np -- number of points for contour
// extra -- called just before saving figure
// axequal -- axis.equal
// vmin -- min 0 values
// vmax -- max 1 values
// f -- function to plot filled contour. can be <nil>
// gs -- functions to plot contour @ level 0. can be <nil>
func PlotTwoVarsContour(dirout, fnkey string, x []float64, np int, extra func(), axequal bool,
vmin, vmax []float64, f TwoVarsFunc_t, gs ...TwoVarsFunc_t) {
if fnkey == "" {
return
}
chk.IntAssert(len(vmin), 2)
chk.IntAssert(len(vmax), 2)
V0, V1 := utl.MeshGrid2D(vmin[0], vmax[0], vmin[1], vmax[1], np, np)
var Zf [][]float64
var Zg [][][]float64
if f != nil {
Zf = la.MatAlloc(np, np)
}
if len(gs) > 0 {
Zg = utl.Deep3alloc(len(gs), np, np)
}
xtmp := make([]float64, 2)
for i := 0; i < np; i++ {
for j := 0; j < np; j++ {
xtmp[0], xtmp[1] = V0[i][j], V1[i][j]
if f != nil {
Zf[i][j] = f(xtmp)
}
for k, g := range gs {
Zg[k][i][j] = g(xtmp)
}
}
}
plt.Reset()
plt.SetForEps(0.8, 350)
if f != nil {
cmapidx := 0
plt.Contour(V0, V1, Zf, io.Sf("fsz=7, cmapidx=%d", cmapidx))
}
for k, _ := range gs {
plt.ContourSimple(V0, V1, Zg[k], false, 8, "zorder=5, levels=[0], colors=['yellow'], linewidths=[2], clip_on=0")
}
if x != nil {
plt.PlotOne(x[0], x[1], "'r*', label='optimum', zorder=10")
}
if extra != nil {
extra()
}
if dirout == "" {
dirout = "."
}
plt.Cross("clr='grey'")
plt.SetXnticks(11)
plt.SetYnticks(11)
if axequal {
plt.Equal()
}
plt.AxisRange(vmin[0], vmax[0], vmin[1], vmax[1])
args := "leg_out='1', leg_ncol=4, leg_hlen=1.5"
plt.Gll("$x_0$", "$x_1$", args)
plt.SaveD(dirout, fnkey+".eps")
}
func main() {
// input data
fn, fnk := io.ArgToFilename(0, "nurbs01", ".msh", true)
ctrl := io.ArgToBool(1, true)
ids := io.ArgToBool(2, true)
useminmax := io.ArgToBool(3, false)
axisequal := io.ArgToBool(4, true)
xmin := io.ArgToFloat(5, 0)
xmax := io.ArgToFloat(6, 0)
ymin := io.ArgToFloat(7, 0)
ymax := io.ArgToFloat(8, 0)
eps := io.ArgToBool(9, false)
npts := io.ArgToInt(10, 41)
// print input table
io.Pf("\n%s\n", io.ArgsTable("INPUT ARGUMENTS",
"mesh filename", "fn", fn,
"show control points", "ctrl", ctrl,
"show ids", "ids", ids,
"use xmin,xmax,ymin,ymax", "useminmax", useminmax,
"enforce axis.equal", "axisequal", axisequal,
"min(x)", "xmin", xmin,
"max(x)", "xmax", xmax,
"min(y)", "ymin", ymin,
"max(y)", "ymax", ymax,
"generate eps instead of png", "eps", eps,
"number of divisions", "npts", npts,
))
// load nurbss
B := gm.ReadMsh(fnk)
// plot
if eps {
plt.SetForEps(0.75, 500)
} else {
plt.SetForPng(0.75, 500, 150)
}
for _, b := range B {
if ctrl {
b.DrawCtrl2d(ids, "", "")
}
b.DrawElems2d(npts, ids, "", "")
}
if axisequal {
plt.Equal()
}
if useminmax {
plt.AxisRange(xmin, xmax, ymin, ymax)
}
ext := ".png"
if eps {
ext = ".eps"
}
plt.Save(fnk + ext)
}
func main() {
// GA parameters
C := goga.ReadConfParams("tsp-simple.json")
rnd.Init(C.Seed)
// location / coordinates of stations
locations := [][]float64{
{60, 200}, {180, 200}, {80, 180}, {140, 180}, {20, 160}, {100, 160}, {200, 160},
{140, 140}, {40, 120}, {100, 120}, {180, 100}, {60, 80}, {120, 80}, {180, 60},
{20, 40}, {100, 40}, {200, 40}, {20, 20}, {60, 20}, {160, 20},
}
nstations := len(locations)
C.SetIntOrd(nstations)
C.CalcDerived()
// objective value function
C.OvaOor = func(ind *goga.Individual, idIsland, time int, report *bytes.Buffer) {
L := locations
ids := ind.Ints
dist := 0.0
for i := 1; i < nstations; i++ {
a, b := ids[i-1], ids[i]
dist += math.Sqrt(math.Pow(L[b][0]-L[a][0], 2.0) + math.Pow(L[b][1]-L[a][1], 2.0))
}
a, b := ids[nstations-1], ids[0]
dist += math.Sqrt(math.Pow(L[b][0]-L[a][0], 2.0) + math.Pow(L[b][1]-L[a][1], 2.0))
ind.Ovas[0] = dist
return
}
// evolver
nova, noor := 1, 0
evo := goga.NewEvolver(nova, noor, C)
evo.Run()
// results
io.Pfgreen("best = %v\n", evo.Best.Ints)
io.Pfgreen("best OVA = %v (871.117353844847)\n\n", evo.Best.Ovas[0])
// plot travelling salesman path
if C.DoPlot {
plt.SetForEps(1, 300)
X, Y := make([]float64, nstations), make([]float64, nstations)
for k, id := range evo.Best.Ints {
X[k], Y[k] = locations[id][0], locations[id][1]
plt.PlotOne(X[k], Y[k], "'r.', ms=5, clip_on=0, zorder=20")
plt.Text(X[k], Y[k], io.Sf("%d", id), "fontsize=7, clip_on=0, zorder=30")
}
plt.Plot(X, Y, "'b-', clip_on=0, zorder=10")
plt.Plot([]float64{X[0], X[nstations-1]}, []float64{Y[0], Y[nstations-1]}, "'b-', clip_on=0, zorder=10")
plt.Equal()
plt.AxisRange(10, 210, 10, 210)
plt.Gll("$x$", "$y$", "")
plt.SaveD("/tmp/goga", "test_evo04.eps")
}
}
func Test_flt04(tst *testing.T) {
//verbose()
chk.PrintTitle("flt04. two-bar truss. Pareto-optimal")
// data. from Coelho (2007) page 19
ρ := 0.283 // lb/in³
H := 100.0 // in
P := 1e4 // lb
E := 3e7 // lb/in²
σ0 := 2e4 // lb/in²
// parameters
var opt Optimiser
opt.Default()
opt.Nsol = 30
opt.Ncpu = 1
opt.Tf = 100
opt.LatinDup = 5
opt.FltMin = []float64{0.1, 0.5}
opt.FltMax = []float64{2.25, 2.5}
nf, ng, nh := 2, 2, 0
// initialise optimiser
TSQ2 := 2.0 * math.Sqrt2
opt.Init(GenTrialSolutions, nil, func(f, g, h, x []float64, ξ []int, cpu int) {
f[0] = 2.0 * ρ * H * x[1] * math.Sqrt(1.0+x[0]*x[0])
f[1] = P * H * math.Pow(1.0+x[0]*x[0], 1.5) * math.Sqrt(1.0+math.Pow(x[0], 4.0)) / (TSQ2 * E * x[0] * x[0] * x[1])
g[0] = σ0 - P*(1.0+x[0])*math.Sqrt(1.0+x[0]*x[0])/(TSQ2*x[0]*x[1])
g[1] = σ0 - P*(1.0-x[0])*math.Sqrt(1.0+x[0]*x[0])/(TSQ2*x[0]*x[1])
}, nf, ng, nh)
// initial solutions
sols0 := opt.GetSolutionsCopy()
// solve
opt.Solve()
// plot
if chk.Verbose {
_, dat, _ := io.ReadTable("data/coelho-fig1.6.dat")
pp := NewPlotParams(false)
pp.FnKey = "fig-flt04"
pp.FmtSols.C = "gray"
pp.WithAll = true
pp.Extra = func() {
plt.Plot(dat["f1"], dat["f2"], "'b-',ms=3,markeredgecolor='b'")
plt.AxisRange(0, 250, 0, 0.15)
}
opt.PlotOvaOvaPareto(sols0, 0, 1, pp)
}
}
// Draw2d draws bins' grid
func (o *Bins) Draw2d(withtxt bool) {
// horizontal lines
x := []float64{o.Xi[0], o.Xi[0] + o.L[0] + o.S}
y := make([]float64, 2)
for j := 0; j < o.N[1]+1; j++ {
y[0] = o.Xi[1] + float64(j)*o.S
y[1] = y[0]
plt.Plot(x, y, "'-', color='#4f3677', clip_on=0")
}
// vertical lines
y[0] = o.Xi[1]
y[1] = o.Xi[1] + o.L[1] + o.S
for i := 0; i < o.N[0]+1; i++ {
x[0] = o.Xi[0] + float64(i)*o.S
x[1] = x[0]
plt.Plot(x, y, "'k-', color='#4f3677', clip_on=0")
}
// plot items
for _, bin := range o.All {
if bin == nil {
continue
}
for _, entry := range bin.Entries {
plt.PlotOne(entry.X[0], entry.X[1], "'r.', clip_on=0")
}
}
// labels
if withtxt {
for j := 0; j < o.N[1]; j++ {
for i := 0; i < o.N[0]; i++ {
idx := i + j*o.N[0]
x := o.Xi[0] + float64(i)*o.S + 0.02*o.S
y := o.Xi[1] + float64(j)*o.S + 0.02*o.S
plt.Text(x, y, io.Sf("%d", idx), "size=7")
}
}
}
// setup
plt.Equal()
plt.AxisRange(o.Xi[0]-0.1, o.Xf[0]+o.S+0.1, o.Xi[1]-0.1, o.Xf[1]+o.S+0.1)
}
func Test_delaunay01(tst *testing.T) {
//verbose()
chk.PrintTitle("delaunay01")
// points
X := []float64{0, 1, 1, 0, 0.5}
Y := []float64{0, 0, 1, 1, 0.5}
// generate
V, C, err := Delaunay(X, Y, chk.Verbose)
if err != nil {
tst.Errorf("%v\n", err)
return
}
// check
xout := make([]float64, len(V))
yout := make([]float64, len(V))
for i, v := range V {
io.Pforan("vert %2d : coords = %v\n", i, v)
xout[i] = v[0]
yout[i] = v[1]
}
chk.Vector(tst, "X", 1e-15, xout, X)
chk.Vector(tst, "Y", 1e-15, yout, Y)
for i, c := range C {
io.Pforan("cell %2d : verts = %v\n", i, c)
}
chk.Ints(tst, "verts of cell 0", C[0], []int{3, 0, 4})
chk.Ints(tst, "verts of cell 1", C[1], []int{4, 1, 2})
chk.Ints(tst, "verts of cell 2", C[2], []int{1, 4, 0})
chk.Ints(tst, "verts of cell 3", C[3], []int{4, 2, 3})
// plot
if chk.Verbose {
plt.SetForPng(1, 300, 150)
Draw(V, C, nil)
plt.Equal()
plt.AxisRange(-0.1, 1.1, -0.1, 1.1)
plt.Gll("x", "y", "")
plt.SaveD("/tmp/gosl/tri", "delaunay01.png")
}
}
// Draw draws grid
// r -- radius of circles
// W -- width of paths
// dwt -- δwt for positioning text (w = W/2)
// arrow_scale -- scale for arrows. use 0 for default value
func (o *Graph) Draw(dirout, fname string, r, W, dwt, arrow_scale float64,
verts_lbls map[int]string, verts_fsz float64, verts_clr string,
edges_lbls map[int]string, edges_fsz float64, edges_clr string) {
if len(o.Verts) < 1 {
return
}
xmin, ymin := o.Verts[0][0], o.Verts[0][1]
xmax, ymax := xmin, ymin
var lbl string
for i, v := range o.Verts {
if verts_lbls == nil {
lbl = io.Sf("%d", i)
} else {
lbl = verts_lbls[i]
}
plt.Text(v[0], v[1], lbl, io.Sf("clip_on=0, color='%s', fontsize=%g, ha='center', va='center'", verts_clr, verts_fsz))
plt.Circle(v[0], v[1], r, "clip_on=0, ec='k', lw=0.8")
xmin, ymin = utl.Min(xmin, v[0]), utl.Min(ymin, v[1])
xmax, ymax = utl.Max(xmax, v[0]), utl.Max(ymax, v[1])
}
if W > 2*r {
W = 1.8 * r
}
w := W / 2.0
xa, xb := make([]float64, 2), make([]float64, 2)
xc, dx := make([]float64, 2), make([]float64, 2)
mu, nu := make([]float64, 2), make([]float64, 2)
xi, xj := make([]float64, 2), make([]float64, 2)
l := math.Sqrt(r*r - w*w)
var L float64
if arrow_scale <= 0 {
arrow_scale = 20
}
for k, e := range o.Edges {
L = 0.0
for i := 0; i < 2; i++ {
xa[i] = o.Verts[e[0]][i]
xb[i] = o.Verts[e[1]][i]
xc[i] = (xa[i] + xb[i]) / 2.0
dx[i] = xb[i] - xa[i]
L += dx[i] * dx[i]
}
L = math.Sqrt(L)
mu[0], mu[1] = dx[0]/L, dx[1]/L
nu[0], nu[1] = -dx[1]/L, dx[0]/L
for i := 0; i < 2; i++ {
xi[i] = xa[i] + l*mu[i] - w*nu[i]
xj[i] = xb[i] - l*mu[i] - w*nu[i]
xc[i] = (xi[i]+xj[i])/2.0 - dwt*nu[i]
}
plt.Arrow(xi[0], xi[1], xj[0], xj[1], io.Sf("st='->', sc=%g", arrow_scale))
if edges_lbls == nil {
lbl = io.Sf("%d", k)
} else {
lbl = edges_lbls[k]
}
plt.Text(xc[0], xc[1], lbl, io.Sf("clip_on=0, color='%s', fontsize=%g, ha='center', va='center'", edges_clr, edges_fsz))
}
xmin -= r
xmax += r
ymin -= r
ymax += r
plt.AxisOff()
plt.Equal()
plt.AxisRange(xmin, xmax, ymin, ymax)
plt.SaveD(dirout, fname)
}
// Plot plots contour
func (o *SimpleFltProb) Plot(fnkey string) {
// check
if !o.C.DoPlot {
return
}
// limits and meshgrid
xmin, xmax := o.C.RangeFlt[0][0], o.C.RangeFlt[0][1]
ymin, ymax := o.C.RangeFlt[1][0], o.C.RangeFlt[1][1]
// auxiliary variables
X, Y := utl.MeshGrid2D(xmin, xmax, ymin, ymax, o.PltNpts, o.PltNpts)
Zf := utl.DblsAlloc(o.PltNpts, o.PltNpts)
var Zg [][][]float64
var Zh [][][]float64
if o.ng > 0 {
Zg = utl.Deep3alloc(o.ng, o.PltNpts, o.PltNpts)
}
if o.nh > 0 {
Zh = utl.Deep3alloc(o.nh, o.PltNpts, o.PltNpts)
}
// compute values
x := make([]float64, 2)
for i := 0; i < o.PltNpts; i++ {
for j := 0; j < o.PltNpts; j++ {
x[0], x[1] = X[i][j], Y[i][j]
o.Fcn(o.ff[0], o.gg[0], o.hh[0], x)
Zf[i][j] = o.ff[0][o.PltIdxF]
for k, g := range o.gg[0] {
Zg[k][i][j] = g
}
for k, h := range o.hh[0] {
Zh[k][i][j] = h
}
}
}
// prepare plot area
plt.Reset()
plt.SetForEps(0.8, 350)
// plot f
if o.PltArgs != "" {
o.PltArgs = "," + o.PltArgs
}
if o.PltCsimple {
plt.ContourSimple(X, Y, Zf, true, 7, "colors=['k'], fsz=7"+o.PltArgs)
} else {
plt.Contour(X, Y, Zf, io.Sf("fsz=7, cmapidx=%d"+o.PltArgs, o.PltCmapIdx))
}
// plot g
clr := "yellow"
if o.PltCsimple {
clr = "blue"
}
for _, g := range Zg {
plt.ContourSimple(X, Y, g, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", clr, o.PltLwg))
}
// plot h
clr = "yellow"
if o.PltCsimple {
clr = "blue"
}
for _, h := range Zh {
plt.ContourSimple(X, Y, h, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", clr, o.PltLwh))
}
// initial populations
l := "initial population"
for _, pop := range o.PopsIni {
for _, ind := range pop {
x := ind.GetFloats()
plt.PlotOne(x[0], x[1], io.Sf("'k.', zorder=20, clip_on=0, label='%s'", l))
l = ""
}
}
// final populations
l = "final population"
for _, pop := range o.PopsBest {
for _, ind := range pop {
x := ind.GetFloats()
plt.PlotOne(x[0], x[1], io.Sf("'ko', ms=6, zorder=30, clip_on=0, label='%s', markerfacecolor='none'", l))
l = ""
}
}
// extra
if o.PltExtra != nil {
o.PltExtra()
}
// best result
if o.Nfeasible > 0 {
x, _, _, _ := o.find_best()
plt.PlotOne(x[0], x[1], "'m*', zorder=50, clip_on=0, label='best', markeredgecolor='m'")
}
// save figure
plt.Cross("clr='grey'")
if o.PltAxEqual {
plt.Equal()
}
plt.AxisRange(xmin, xmax, ymin, ymax)
plt.Gll("$x_0$", "$x_1$", "leg_out=1, leg_ncol=4, leg_hlen=1.5")
plt.SaveD(o.PltDirout, fnkey+".eps")
}
func runone(ncpu int) (nsol, tf int, elaspsedTime time.Duration) {
// input filename
fn, fnkey := io.ArgToFilename(0, "ground10", ".sim", true)
// GA parameters
var opt goga.Optimiser
opt.Read("ga-" + fnkey + ".json")
opt.GenType = "rnd"
nsol, tf = opt.Nsol, opt.Tf
postproc := true
if ncpu > 0 {
opt.Ncpu = ncpu
postproc = false
}
// FEM
data := make([]*FemData, opt.Ncpu)
for i := 0; i < opt.Ncpu; i++ {
data[i] = NewData(fn, fnkey, i)
}
io.Pforan("MaxWeight = %v\n", data[0].MaxWeight)
// set integers
if data[0].Opt.BinInt {
opt.CxInt = goga.CxInt
opt.MtInt = goga.MtIntBin
opt.BinInt = data[0].Ncells
}
// set floats
opt.FltMin = make([]float64, data[0].Nareas)
opt.FltMax = make([]float64, data[0].Nareas)
for i := 0; i < data[0].Nareas; i++ {
opt.FltMin[i] = data[0].Opt.Amin
opt.FltMax[i] = data[0].Opt.Amax
}
// initialise optimiser
opt.Nova = 2 // weight and deflection
opt.Noor = 4 // mobility, feasibility, maxdeflection, stress
opt.Init(goga.GenTrialSolutions, func(sol *goga.Solution, cpu int) {
mob, fail, weight, umax, _, errU, errS := data[cpu].RunFEM(sol.Int, sol.Flt, 0, false)
sol.Ova[0] = weight
sol.Ova[1] = umax
sol.Oor[0] = mob
sol.Oor[1] = fail
sol.Oor[2] = errU
sol.Oor[3] = errS
}, nil, 0, 0, 0)
// initial solutions
var sols0 []*goga.Solution
if false {
sols0 = opt.GetSolutionsCopy()
}
// benchmark
initialTime := time.Now()
defer func() {
elaspsedTime = time.Now().Sub(initialTime)
}()
// solve
opt.Verbose = true
opt.Solve()
goga.SortByOva(opt.Solutions, 0)
// post processing
if !postproc {
return
}
// check
nfailed, front0 := goga.CheckFront0(&opt, true)
// save results
var log, res bytes.Buffer
io.Ff(&log, opt.LogParams())
io.Ff(&res, PrintSolutions(data[0], opt.Solutions))
io.Ff(&res, io.Sf("\n\nnfailed = %d\n", nfailed))
io.WriteFileVD("/tmp/goga", fnkey+".log", &log)
io.WriteFileVD("/tmp/goga", fnkey+".res", &res)
// plot Pareto-optimal front
feasibleOnly := true
plt.SetForEps(0.8, 350)
if strings.HasPrefix(fnkey, "ground10") {
_, ref, _ := io.ReadTable("p460_fig300.dat")
plt.Plot(ref["w"], ref["u"], "'b-', label='reference'")
}
fmtAll := &plt.Fmt{L: "final solutions", M: ".", C: "orange", Ls: "none", Ms: 3}
fmtFront := &plt.Fmt{L: "final Pareto front", C: "r", M: "o", Ms: 3, Ls: "none"}
goga.PlotOvaOvaPareto(&opt, sols0, 0, 1, feasibleOnly, fmtAll, fmtFront)
plt.Gll("weight ($f_0$)", "deflection ($f_1)$", "") //, "leg_out=1, leg_ncol=4, leg_hlen=1.5")
if strings.HasPrefix(fnkey, "ground10") {
plt.AxisRange(1800, 14000, 1, 6)
}
// plot selected results
ia, ib, ic, id, ie := 0, 0, 0, 0, 0
nfront0 := len(front0)
io.Pforan("nfront0 = %v\n", nfront0)
if nfront0 > 4 {
ib = nfront0 / 10
ic = nfront0 / 5
id = nfront0 / 2
ie = nfront0 - 1
}
A := front0[ia]
B := front0[ib]
C := front0[ic]
D := front0[id]
E := front0[ie]
wid, hei := 0.20, 0.10
draw_truss(data[0], "A", A, 0.17, 0.75, wid, hei)
draw_truss(data[0], "B", B, 0.20, 0.55, wid, hei)
draw_truss(data[0], "C", C, 0.28, 0.33, wid, hei)
draw_truss(data[0], "D", D, 0.47, 0.22, wid, hei)
draw_truss(data[0], "E", E, 0.70, 0.18, wid, hei)
// save figure
plt.SaveD("/tmp/goga", fnkey+".eps")
// tex file
title := "Shape and topology optimisation. Results."
label := "topoFront"
document := true
compact := true
tex_results("/tmp/goga", "tmp_"+fnkey, title, label, data[0], A, B, C, D, E, document, compact)
document = false
tex_results("/tmp/goga", fnkey, title, label, data[0], A, B, C, D, E, document, compact)
return
}
func solve_problem(problem int) (opt *goga.Optimiser) {
io.Pf("\n\n------------------------------------- problem = %d ---------------------------------------\n", problem)
// parameters
opt = new(goga.Optimiser)
opt.Default()
opt.Ncpu = 1
opt.Tf = 500
opt.Verbose = false
opt.Nsamples = 2
opt.GenType = "latin"
opt.DEC = 0.1
// options for report
opt.HistNsta = 6
opt.HistLen = 13
opt.RptFmtE = "%.4e"
opt.RptFmtL = "%.4e"
opt.RptFmtEdev = "%.3e"
opt.RptFmtLdev = "%.3e"
// problem variables
var fmin, fmax []float64
var nf, ng, nh int
var fcn goga.MinProb_t
// problems
switch problem {
// problem # 1 -- ZDT1, Deb 2001, p356
case 1:
opt.Ncpu = 6
opt.RptName = "ZDT1"
n := 30
opt.FltMin = make([]float64, n)
opt.FltMax = make([]float64, n)
for i := 0; i < n; i++ {
opt.FltMin[i] = 0
opt.FltMax[i] = 1
}
nf, ng, nh = 2, 0, 0
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
f[0] = x[0]
sum := 0.0
for i := 1; i < n; i++ {
sum += x[i]
}
c0 := 1.0 + 9.0*sum/float64(n-1)
c1 := 1.0 - math.Sqrt(f[0]/c0)
f[1] = c0 * c1
}
fmin = []float64{0, 0}
fmax = []float64{1, 1}
opt.F1F0_func = func(f0 float64) float64 {
return 1.0 - math.Sqrt(f0)
}
// arc length = sqrt(5)/2 + log(sqrt(5)+2)/4 ≈ 1.4789428575445975
opt.F1F0_arcLenRef = math.Sqrt(5.0)/2.0 + math.Log(math.Sqrt(5.0)+2.0)/4.0
// problem # 2 -- ZDT2, Deb 2001, p356
case 2:
opt.Ncpu = 6
opt.RptName = "ZDT2"
n := 30
opt.FltMin = make([]float64, n)
opt.FltMax = make([]float64, n)
for i := 0; i < n; i++ {
opt.FltMin[i] = 0
opt.FltMax[i] = 1
}
nf, ng, nh = 2, 0, 0
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
f[0] = x[0]
sum := 0.0
for i := 1; i < n; i++ {
sum += x[i]
}
c0 := 1.0 + 9.0*sum/float64(n-1)
c1 := 1.0 - math.Pow(f[0]/c0, 2.0)
f[1] = c0 * c1
}
fmin = []float64{0, 0}
fmax = []float64{1, 1}
opt.F1F0_func = func(f0 float64) float64 {
return 1.0 - math.Pow(f0, 2.0)
}
// arc length = sqrt(5)/2 + log(sqrt(5)+2)/4 ≈ 1.4789428575445975
opt.F1F0_arcLenRef = math.Sqrt(5.0)/2.0 + math.Log(math.Sqrt(5.0)+2.0)/4.0
// problem # 3 -- ZDT3, Deb 2001, p356
case 3:
opt.Ncpu = 6
opt.RptName = "ZDT3"
n := 30
opt.FltMin = make([]float64, n)
opt.FltMax = make([]float64, n)
for i := 0; i < n; i++ {
opt.FltMin[i] = 0
opt.FltMax[i] = 1
}
nf, ng, nh = 2, 0, 0
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
f[0] = x[0]
sum := 0.0
for i := 1; i < n; i++ {
sum += x[i]
}
c0 := 1.0 + 9.0*sum/float64(n-1)
c1 := 1.0 - math.Sqrt(f[0]/c0) - math.Sin(10.0*math.Pi*f[0])*f[0]/c0
f[1] = c0 * c1
}
fmin = []float64{0, -1}
fmax = []float64{1, 1}
opt.F1F0_func = func(f0 float64) float64 {
return 1.0 - math.Sqrt(f0) - math.Sin(10.0*math.Pi*f0)*f0
}
opt.F1F0_f0ranges = [][]float64{
{0.000000100000000, 0.083001534925223},
{0.182228728029413, 0.257762363387862},
{0.409313674808657, 0.453882104088830},
{0.618396794416602, 0.652511703804663},
{0.823331798326633, 0.851832865436414},
}
opt.F1F0_arcLenRef = 1.811
// problem # 4 -- ZDT4, Deb 2001, p358
case 4:
opt.Ncpu = 2
opt.RptName = "ZDT4"
n := 10
opt.FltMin = make([]float64, n)
opt.FltMax = make([]float64, n)
opt.FltMin[0] = 0
opt.FltMax[0] = 1
for i := 1; i < n; i++ {
opt.FltMin[i] = -5
opt.FltMax[i] = 5
}
nf, ng, nh = 2, 0, 0
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
f[0] = x[0]
sum := 0.0
w := 4.0 * math.Pi
for i := 1; i < n; i++ {
sum += x[i]*x[i] - 10.0*math.Cos(w*x[i])
}
c0 := 1.0 + 10.0*float64(n-1) + sum
c1 := 1.0 - math.Sqrt(f[0]/c0)
f[1] = c0 * c1
}
fmin = []float64{0, 0}
fmax = []float64{1, 1}
opt.F1F0_func = func(f0 float64) float64 {
return 1.0 - math.Sqrt(f0)
}
// arc length = sqrt(5)/2 + log(sqrt(5)+2)/4 ≈ 1.4789428575445975
opt.F1F0_arcLenRef = math.Sqrt(5.0)/2.0 + math.Log(math.Sqrt(5.0)+2.0)/4.0
// problem # 5 -- FON (Fonseca and Fleming 1995), Deb 2001, p339
case 5:
opt.DEC = 0.8
opt.Ncpu = 2
opt.RptName = "FON"
n := 10
opt.FltMin = make([]float64, n)
opt.FltMax = make([]float64, n)
for i := 0; i < n; i++ {
opt.FltMin[i] = -4
opt.FltMax[i] = 4
}
nf, ng, nh = 2, 0, 0
coef := 1.0 / math.Sqrt(float64(n))
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
sum0, sum1 := 0.0, 0.0
for i := 0; i < n; i++ {
sum0 += math.Pow(x[i]-coef, 2.0)
sum1 += math.Pow(x[i]+coef, 2.0)
}
f[0] = 1.0 - math.Exp(-sum0)
f[1] = 1.0 - math.Exp(-sum1)
}
fmin = []float64{0, 0}
fmax = []float64{0.98, 1}
opt.F1F0_func = func(f0 float64) float64 {
return 1.0 - math.Exp(-math.Pow(2.0-math.Sqrt(-math.Log(1.0-f0)), 2.0))
}
opt.F1F0_arcLenRef = 1.45831385
// problem # 6 -- ZDT6, Deb 2001, p360
case 6:
opt.Ncpu = 2
opt.RptName = "ZDT6"
n := 10
opt.FltMin = make([]float64, n)
opt.FltMax = make([]float64, n)
for i := 0; i < n; i++ {
opt.FltMin[i] = 0
opt.FltMax[i] = 1
}
nf, ng, nh = 2, 0, 0
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
w := 6.0 * math.Pi
f[0] = 1.0 - math.Exp(-4.0*x[0])*math.Pow(math.Sin(w*x[0]), 6.0)
sum := 0.0
for i := 1; i < n; i++ {
sum += x[i]
}
w = float64(n - 1)
c0 := 1.0 + 9.0*math.Pow(sum/w, 0.25)
c1 := 1.0 - math.Pow(f[0]/c0, 2.0)
f[1] = c0 * c1
}
opt.F1F0_func = func(f0 float64) float64 {
return 1.0 - math.Pow(f0, 2.0)
}
xs := math.Atan(9.0*math.Pi) / (6.0 * math.Pi)
f0min := 1.0 - math.Exp(-4.0*xs)*math.Pow(math.Sin(6.0*math.Pi*xs), 6.0)
f1max := opt.F1F0_func(f0min)
io.Pforan("xs=%v f0min=%v f1max=%v\n", xs, f0min, f1max)
// xs=0.08145779687998356 f0min=0.2807753188153699 f1max=0.9211652203441274
fmin = []float64{f0min, 0}
fmax = []float64{1, 1}
opt.F1F0_arcLenRef = 1.184
default:
chk.Panic("problem %d is not available", problem)
}
// number of trial solutions and number of groups
opt.Nsol = len(opt.FltMin) * 10
// initialise optimiser
opt.Init(goga.GenTrialSolutions, nil, fcn, nf, ng, nh)
// initial solutions
var sols0 []*goga.Solution
if false {
sols0 = opt.GetSolutionsCopy()
}
// solve
opt.RunMany("", "")
goga.StatF1F0(opt, true)
// check
goga.CheckFront0(opt, true)
// plot
if true {
feasibleOnly := true
plt.SetForEps(0.8, 300)
fmtAll := &plt.Fmt{L: "final solutions", M: ".", C: "orange", Ls: "none", Ms: 3}
fmtFront := &plt.Fmt{L: "final Pareto front", C: "r", M: "o", Ms: 3, Ls: "none"}
goga.PlotOvaOvaPareto(opt, sols0, 0, 1, feasibleOnly, fmtAll, fmtFront)
np := 201
F0 := utl.LinSpace(fmin[0], fmax[0], np)
F1 := make([]float64, np)
for i := 0; i < np; i++ {
F1[i] = opt.F1F0_func(F0[i])
}
plt.Plot(F0, F1, io.Sf("'b-', label='%s'", opt.RptName))
for _, f0vals := range opt.F1F0_f0ranges {
f0A, f0B := f0vals[0], f0vals[1]
f1A, f1B := opt.F1F0_func(f0A), opt.F1F0_func(f0B)
plt.PlotOne(f0A, f1A, "'g_', mew=1.5, ms=10, clip_on=0")
plt.PlotOne(f0B, f1B, "'g|', mew=1.5, ms=10, clip_on=0")
}
plt.AxisRange(fmin[0], fmax[0], fmin[1], fmax[1])
plt.Gll("$f_0$", "$f_1$", "")
plt.SaveD("/tmp/goga", io.Sf("%s.eps", opt.RptName))
}
return
}
// Draw2d draws bins' grid
func (o *Bins) Draw2d(withtxt, withgrid, withentries, setup bool, selBins map[int]bool) {
if withgrid {
// horizontal lines
x := []float64{o.Xi[0], o.Xi[0] + o.L[0] + o.S[0]}
y := make([]float64, 2)
for j := 0; j < o.N[1]+1; j++ {
y[0] = o.Xi[1] + float64(j)*o.S[1]
y[1] = y[0]
plt.Plot(x, y, "'-', color='#4f3677', clip_on=0")
}
// vertical lines
y[0] = o.Xi[1]
y[1] = o.Xi[1] + o.L[1] + o.S[1]
for i := 0; i < o.N[0]+1; i++ {
x[0] = o.Xi[0] + float64(i)*o.S[0]
x[1] = x[0]
plt.Plot(x, y, "'k-', color='#4f3677', clip_on=0")
}
}
// selected bins
nxy := o.N[0] * o.N[1]
for idx, _ := range selBins {
i := idx % o.N[0] // indices representing bin
j := (idx % nxy) / o.N[0]
x := o.Xi[0] + float64(i)*o.S[0] // coordinates of bin corner
y := o.Xi[1] + float64(j)*o.S[1]
plt.DrawPolyline([][]float64{
{x, y},
{x + o.S[0], y},
{x + o.S[0], y + o.S[1]},
{x, y + o.S[1]},
}, &plt.Sty{Fc: "#fbefdc", Ec: "#8e8371", Lw: 0.5, Closed: true}, "clip_on=0")
}
// plot items
if withentries {
for _, bin := range o.All {
if bin == nil {
continue
}
for _, entry := range bin.Entries {
plt.PlotOne(entry.X[0], entry.X[1], "'r.', clip_on=0")
}
}
}
// labels
if withtxt {
for j := 0; j < o.N[1]; j++ {
for i := 0; i < o.N[0]; i++ {
idx := i + j*o.N[0]
x := o.Xi[0] + float64(i)*o.S[0] + 0.02*o.S[0]
y := o.Xi[1] + float64(j)*o.S[1] + 0.02*o.S[1]
plt.Text(x, y, io.Sf("%d", idx), "size=7")
}
}
}
// setup
if setup {
plt.Equal()
plt.AxisRange(o.Xi[0]-0.1, o.Xf[0]+o.S[0]+0.1, o.Xi[1]-0.1, o.Xf[1]+o.S[1]+0.1)
}
}
func solve_problem(problem int) (opt *goga.Optimiser) {
io.Pf("\n\n------------------------------------- problem = %d ---------------------------------------\n", problem)
// parameters
opt = new(goga.Optimiser)
opt.Default()
opt.Ncpu = 3
opt.Tf = 500
opt.Verbose = false
opt.Nsamples = 1000
opt.GenType = "latin"
opt.DEC = 0.1
// options for report
opt.HistNsta = 6
opt.HistLen = 13
opt.RptFmtE = "%.4e"
opt.RptFmtL = "%.4e"
opt.RptFmtEdev = "%.3e"
opt.RptFmtLdev = "%.3e"
// problem variables
nx := 10
opt.RptName = io.Sf("CTP%d", problem)
opt.Nsol = 120
opt.FltMin = make([]float64, nx)
opt.FltMax = make([]float64, nx)
for i := 0; i < nx; i++ {
opt.FltMin[i] = 0
opt.FltMax[i] = 1
}
nf, ng, nh := 2, 1, 0
// extra problem variables
var f1max float64
var fcn goga.MinProb_t
var extraplot func()
// problems
switch problem {
// problem # 0 -- TNK
case 0:
ng = 2
f1max = 1.21
opt.RptName = "TNK"
opt.FltMin = []float64{0, 0}
opt.FltMax = []float64{PI, PI}
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
f[0] = x[0]
f[1] = x[1]
g[0] = x[0]*x[0] + x[1]*x[1] - 1.0 - 0.1*math.Cos(16.0*math.Atan2(x[0], x[1]))
g[1] = 0.5 - math.Pow(x[0]-0.5, 2.0) - math.Pow(x[1]-0.5, 2.0)
}
extraplot = func() {
np := 301
X, Y := utl.MeshGrid2D(0, 1.3, 0, 1.3, np, np)
Z1, Z2, Z3 := utl.DblsAlloc(np, np), utl.DblsAlloc(np, np), utl.DblsAlloc(np, np)
for j := 0; j < np; j++ {
for i := 0; i < np; i++ {
g1 := 0.5 - math.Pow(X[i][j]-0.5, 2.0) - math.Pow(Y[i][j]-0.5, 2.0)
if g1 >= 0 {
Z1[i][j] = X[i][j]*X[i][j] + Y[i][j]*Y[i][j] - 1.0 - 0.1*math.Cos(16.0*math.Atan2(Y[i][j], X[i][j]))
} else {
Z1[i][j] = -1
}
Z2[i][j] = X[i][j]*X[i][j] + Y[i][j]*Y[i][j] - 1.0 - 0.1*math.Cos(16.0*math.Atan2(Y[i][j], X[i][j]))
Z3[i][j] = g1
}
}
plt.Contour(X, Y, Z1, "levels=[0,2],cbar=0,lwd=0.5,fsz=5,cmapidx=6")
plt.Text(0.3, 0.95, "0.000", "size=5,rotation=10")
plt.ContourSimple(X, Y, Z2, false, 7, "linestyles=['-'], linewidths=[0.7], colors=['k'], levels=[0]")
plt.ContourSimple(X, Y, Z3, false, 7, "linestyles=['-'], linewidths=[1.0], colors=['k'], levels=[0]")
}
opt.Multi_fcnErr = func(f []float64) float64 {
return f[0]*f[0] + f[1]*f[1] - 1.0 - 0.1*math.Cos(16.0*math.Atan2(f[0], f[1]))
}
// problem # 1 -- CTP1, Deb 2001, p367, fig 225
case 1:
ng = 2
f1max = 1.0
a0, b0 := 0.858, 0.541
a1, b1 := 0.728, 0.295
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
c0 := 1.0
for i := 1; i < len(x); i++ {
c0 += x[i]
}
f[0] = x[0]
f[1] = c0 * math.Exp(-x[0]/c0)
if true {
g[0] = f[1] - a0*math.Exp(-b0*f[0])
g[1] = f[1] - a1*math.Exp(-b1*f[0])
}
}
f0a := math.Log(a0) / (b0 - 1.0)
f1a := math.Exp(-f0a)
f0b := math.Log(a0/a1) / (b0 - b1)
f1b := a0 * math.Exp(-b0*f0b)
opt.Multi_fcnErr = func(f []float64) float64 {
if f[0] < f0a {
return f[1] - math.Exp(-f[0])
}
if f[0] < f0b {
return f[1] - a0*math.Exp(-b0*f[0])
}
return f[1] - a1*math.Exp(-b1*f[0])
}
extraplot = func() {
np := 201
X, Y := utl.MeshGrid2D(0, 1, 0, 1, np, np)
Z := utl.DblsAlloc(np, np)
for j := 0; j < np; j++ {
for i := 0; i < np; i++ {
Z[i][j] = opt.Multi_fcnErr([]float64{X[i][j], Y[i][j]})
}
}
plt.Contour(X, Y, Z, "levels=[0,0.6],cbar=0,lwd=0.5,fsz=5,cmapidx=6")
F0 := utl.LinSpace(0, 1, 21)
F1r := make([]float64, len(F0))
F1s := make([]float64, len(F0))
F1t := make([]float64, len(F0))
for i, f0 := range F0 {
F1r[i] = math.Exp(-f0)
F1s[i] = a0 * math.Exp(-b0*f0)
F1t[i] = a1 * math.Exp(-b1*f0)
}
plt.Plot(F0, F1r, "'k--',color='blue'")
plt.Plot(F0, F1s, "'k--',color='green'")
plt.Plot(F0, F1t, "'k--',color='gray'")
plt.PlotOne(f0a, f1a, "'k|', ms=20")
plt.PlotOne(f0b, f1b, "'k|', ms=20")
}
// problem # 2 -- CTP2, Deb 2001, p368/369, fig 226
case 2:
f1max = 1.2
θ, a, b := -0.2*PI, 0.2, 10.0
c, d, e := 1.0, 6.0, 1.0
fcn = CTPgenerator(θ, a, b, c, d, e)
extraplot = CTPplotter(θ, a, b, c, d, e, f1max)
opt.Multi_fcnErr = CTPerror1(θ, a, b, c, d, e)
// problem # 3 -- CTP3, Deb 2001, p368/370, fig 227
case 3:
f1max = 1.2
θ, a, b := -0.2*PI, 0.1, 10.0
c, d, e := 1.0, 0.5, 1.0
fcn = CTPgenerator(θ, a, b, c, d, e)
extraplot = CTPplotter(θ, a, b, c, d, e, f1max)
opt.Multi_fcnErr = CTPerror1(θ, a, b, c, d, e)
// problem # 4 -- CTP4, Deb 2001, p368/370, fig 228
case 4:
f1max = 2.0
θ, a, b := -0.2*PI, 0.75, 10.0
c, d, e := 1.0, 0.5, 1.0
fcn = CTPgenerator(θ, a, b, c, d, e)
extraplot = CTPplotter(θ, a, b, c, d, e, f1max)
opt.Multi_fcnErr = CTPerror1(θ, a, b, c, d, e)
// problem # 5 -- CTP5, Deb 2001, p368/371, fig 229
case 5:
f1max = 1.2
θ, a, b := -0.2*PI, 0.1, 10.0
c, d, e := 2.0, 0.5, 1.0
fcn = CTPgenerator(θ, a, b, c, d, e)
extraplot = CTPplotter(θ, a, b, c, d, e, f1max)
opt.Multi_fcnErr = CTPerror1(θ, a, b, c, d, e)
// problem # 6 -- CTP6, Deb 2001, p368/372, fig 230
case 6:
f1max = 5.0
θ, a, b := 0.1*PI, 40.0, 0.5
c, d, e := 1.0, 2.0, -2.0
fcn = CTPgenerator(θ, a, b, c, d, e)
extraplot = func() {
np := 201
X, Y := utl.MeshGrid2D(0, 1, 0, 20, np, np)
Z := utl.DblsAlloc(np, np)
for j := 0; j < np; j++ {
for i := 0; i < np; i++ {
Z[i][j] = CTPconstraint(θ, a, b, c, d, e, X[i][j], Y[i][j])
}
}
plt.Contour(X, Y, Z, "levels=[-30,-15,0,15,30],cbar=0,lwd=0.5,fsz=5,cmapidx=6")
}
opt.Multi_fcnErr = CTPerror1(θ, a, b, c, d, e)
// problem # 7 -- CTP7, Deb 2001, p368/373, fig 231
case 7:
f1max = 1.2
θ, a, b := -0.05*PI, 40.0, 5.0
c, d, e := 1.0, 6.0, 0.0
fcn = CTPgenerator(θ, a, b, c, d, e)
opt.Multi_fcnErr = func(f []float64) float64 { return f[1] - (1.0 - f[0]) }
extraplot = func() {
np := 201
X, Y := utl.MeshGrid2D(0, 1, 0, f1max, np, np)
Z1 := utl.DblsAlloc(np, np)
Z2 := utl.DblsAlloc(np, np)
for j := 0; j < np; j++ {
for i := 0; i < np; i++ {
Z1[i][j] = opt.Multi_fcnErr([]float64{X[i][j], Y[i][j]})
Z2[i][j] = CTPconstraint(θ, a, b, c, d, e, X[i][j], Y[i][j])
}
}
plt.Contour(X, Y, Z2, "levels=[0,3],cbar=0,lwd=0.5,fsz=5,cmapidx=6")
plt.ContourSimple(X, Y, Z1, false, 7, "linestyles=['--'], linewidths=[0.7], colors=['b'], levels=[0]")
}
// problem # 8 -- CTP8, Deb 2001, p368/373, fig 232
case 8:
ng = 2
f1max = 5.0
θ1, a, b := 0.1*PI, 40.0, 0.5
c, d, e := 1.0, 2.0, -2.0
θ2, A, B := -0.05*PI, 40.0, 2.0
C, D, E := 1.0, 6.0, 0.0
sin1, cos1 := math.Sin(θ1), math.Cos(θ1)
sin2, cos2 := math.Sin(θ2), math.Cos(θ2)
fcn = func(f, g, h, x []float64, ξ []int, cpu int) {
c0 := 1.0
for i := 1; i < len(x); i++ {
c0 += x[i]
}
f[0] = x[0]
f[1] = c0 * (1.0 - f[0]/c0)
if true {
c1 := cos1*(f[1]-e) - sin1*f[0]
c2 := sin1*(f[1]-e) + cos1*f[0]
c3 := math.Sin(b * PI * math.Pow(c2, c))
g[0] = c1 - a*math.Pow(math.Abs(c3), d)
d1 := cos2*(f[1]-E) - sin2*f[0]
d2 := sin2*(f[1]-E) + cos2*f[0]
d3 := math.Sin(B * PI * math.Pow(d2, C))
g[1] = d1 - A*math.Pow(math.Abs(d3), D)
}
}
extraplot = func() {
np := 401
X, Y := utl.MeshGrid2D(0, 1, 0, 20, np, np)
Z1 := utl.DblsAlloc(np, np)
Z2 := utl.DblsAlloc(np, np)
Z3 := utl.DblsAlloc(np, np)
for j := 0; j < np; j++ {
for i := 0; i < np; i++ {
c1 := cos1*(Y[i][j]-e) - sin1*X[i][j]
c2 := sin1*(Y[i][j]-e) + cos1*X[i][j]
c3 := math.Sin(b * PI * math.Pow(c2, c))
d1 := cos2*(Y[i][j]-E) - sin2*X[i][j]
d2 := sin2*(Y[i][j]-E) + cos2*X[i][j]
d3 := math.Sin(B * PI * math.Pow(d2, C))
Z1[i][j] = c1 - a*math.Pow(math.Abs(c3), d)
Z2[i][j] = d1 - A*math.Pow(math.Abs(d3), D)
if Z1[i][j] >= 0 && Z2[i][j] >= 0 {
Z3[i][j] = 1
} else {
Z3[i][j] = -1
}
}
}
plt.Contour(X, Y, Z3, "colors=['white','gray'],clabels=0,cbar=0,lwd=0.5,fsz=5")
plt.ContourSimple(X, Y, Z1, false, 7, "linestyles=['--'], linewidths=[0.7], colors=['gray'], levels=[0]")
plt.ContourSimple(X, Y, Z2, false, 7, "linestyles=['--'], linewidths=[0.7], colors=['gray'], levels=[0]")
}
opt.Multi_fcnErr = CTPerror1(θ1, a, b, c, d, e)
default:
chk.Panic("problem %d is not available", problem)
}
// initialise optimiser
opt.Init(goga.GenTrialSolutions, nil, fcn, nf, ng, nh)
// initial solutions
var sols0 []*goga.Solution
if false {
sols0 = opt.GetSolutionsCopy()
}
// solve
opt.RunMany("", "")
goga.StatMulti(opt, true)
io.PfYel("Tsys = %v\n", opt.SysTime)
// check
goga.CheckFront0(opt, true)
// plot
if true {
feasibleOnly := false
plt.SetForEps(0.8, 300)
fmtAll := &plt.Fmt{L: "final solutions", M: ".", C: "orange", Ls: "none", Ms: 3}
fmtFront := &plt.Fmt{L: "final Pareto front", C: "r", M: "o", Ms: 3, Ls: "none"}
goga.PlotOvaOvaPareto(opt, sols0, 0, 1, feasibleOnly, fmtAll, fmtFront)
extraplot()
//plt.AxisYrange(0, f1max)
if problem > 0 && problem < 6 {
plt.Text(0.05, 0.05, "unfeasible", "color='gray', ha='left',va='bottom'")
plt.Text(0.95, f1max-0.05, "feasible", "color='white', ha='right',va='top'")
}
if opt.RptName == "CTP6" {
plt.Text(0.02, 0.15, "unfeasible", "rotation=-7,color='gray', ha='left',va='bottom'")
plt.Text(0.02, 6.50, "unfeasible", "rotation=-7,color='gray', ha='left',va='bottom'")
plt.Text(0.02, 13.0, "unfeasible", "rotation=-7,color='gray', ha='left',va='bottom'")
plt.Text(0.50, 2.40, "feasible", "rotation=-7,color='white', ha='center',va='bottom'")
plt.Text(0.50, 8.80, "feasible", "rotation=-7,color='white', ha='center',va='bottom'")
plt.Text(0.50, 15.30, "feasible", "rotation=-7,color='white', ha='center',va='bottom'")
}
if opt.RptName == "TNK" {
plt.Text(0.05, 0.05, "unfeasible", "color='gray', ha='left',va='bottom'")
plt.Text(0.80, 0.85, "feasible", "color='white', ha='left',va='top'")
plt.Equal()
plt.AxisRange(0, 1.22, 0, 1.22)
}
plt.SaveD("/tmp/goga", io.Sf("%s.eps", opt.RptName))
}
return
}
func Test_int02(tst *testing.T) {
//verbose()
chk.PrintTitle("int02. TSP")
// location / coordinates of stations
locations := [][]float64{
{60, 200}, {180, 200}, {80, 180}, {140, 180}, {20, 160}, {100, 160}, {200, 160},
{140, 140}, {40, 120}, {100, 120}, {180, 100}, {60, 80}, {120, 80}, {180, 60},
{20, 40}, {100, 40}, {200, 40}, {20, 20}, {60, 20}, {160, 20},
}
nstations := len(locations)
// parameters
C := NewConfParams()
C.Nova = 1
C.Noor = 0
C.Nisl = 4
C.Ninds = 24
C.RegTol = 0.3
C.RegPct = 0.2
//C.Dtmig = 30
C.GAtype = "crowd"
C.ParetoPhi = 0.1
C.Elite = false
C.DoPlot = false //chk.Verbose
//C.Rws = true
C.SetIntOrd(nstations)
C.CalcDerived()
// initialise random numbers generator
rnd.Init(0)
// objective value function
C.OvaOor = func(ind *Individual, idIsland, t int, report *bytes.Buffer) {
L := locations
ids := ind.Ints
//io.Pforan("ids = %v\n", ids)
dist := 0.0
for i := 1; i < nstations; i++ {
a, b := ids[i-1], ids[i]
dist += math.Sqrt(math.Pow(L[b][0]-L[a][0], 2.0) + math.Pow(L[b][1]-L[a][1], 2.0))
}
a, b := ids[nstations-1], ids[0]
dist += math.Sqrt(math.Pow(L[b][0]-L[a][0], 2.0) + math.Pow(L[b][1]-L[a][1], 2.0))
ind.Ovas[0] = dist
return
}
// evolver
evo := NewEvolver(C)
// print initial population
pop := evo.Islands[0].Pop
//io.Pf("\n%v\n", pop.Output(nil, false))
// 0,4,8,11,14,17,18,15,12,19,13,16,10,6,1,3,7,9,5,2 894.363
if false {
for i, x := range []int{0, 4, 8, 11, 14, 17, 18, 15, 12, 19, 13, 16, 10, 6, 1, 3, 7, 9, 5, 2} {
pop[0].Ints[i] = x
}
evo.Islands[0].CalcOvs(pop, 0)
evo.Islands[0].CalcDemeritsAndSort(pop)
}
// check initial population
ints := make([]int, nstations)
if false {
for i := 0; i < C.Ninds; i++ {
for j := 0; j < nstations; j++ {
ints[j] = pop[i].Ints[j]
}
sort.Ints(ints)
chk.Ints(tst, "ints", ints, utl.IntRange(nstations))
}
}
// run
evo.Run()
//io.Pf("%v\n", pop.Output(nil, false))
io.Pfgreen("best = %v\n", evo.Best.Ints)
io.Pfgreen("best OVA = %v (871.117353844847)\n\n", evo.Best.Ovas[0])
// best = [18 17 14 11 8 4 0 2 5 9 12 7 6 1 3 10 16 13 19 15]
// best OVA = 953.4643474956656
// best = [8 11 14 17 18 15 12 19 16 13 10 6 1 3 7 9 5 2 0 4]
// best OVA = 871.117353844847
// best = [5 2 0 4 8 11 14 17 18 15 12 19 16 13 10 6 1 3 7 9]
// best OVA = 871.1173538448469
// best = [6 10 13 16 19 15 18 17 14 11 8 4 0 2 5 9 12 7 3 1]
// best OVA = 880.7760751923065
// check final population
if false {
for i := 0; i < C.Ninds; i++ {
for j := 0; j < nstations; j++ {
ints[j] = pop[i].Ints[j]
}
sort.Ints(ints)
chk.Ints(tst, "ints", ints, utl.IntRange(nstations))
}
}
// plot travelling salesman path
if C.DoPlot {
plt.SetForEps(1, 300)
X, Y := make([]float64, nstations), make([]float64, nstations)
for k, id := range evo.Best.Ints {
X[k], Y[k] = locations[id][0], locations[id][1]
plt.PlotOne(X[k], Y[k], "'r.', ms=5, clip_on=0, zorder=20")
plt.Text(X[k], Y[k], io.Sf("%d", id), "fontsize=7, clip_on=0, zorder=30")
}
plt.Plot(X, Y, "'b-', clip_on=0, zorder=10")
plt.Plot([]float64{X[0], X[nstations-1]}, []float64{Y[0], Y[nstations-1]}, "'b-', clip_on=0, zorder=10")
plt.Equal()
plt.AxisRange(10, 210, 10, 210)
plt.Gll("$x$", "$y$", "")
plt.SaveD("/tmp/goga", "test_evo04.eps")
}
}
// Draw2d draws 2D mesh
func (o *Mesh) Draw2d() {
// auxiliary
type triple struct{ a, b, c int } // points on edge
edgesdrawn := make(map[triple]bool) // edges drawn already
var tri triple
// loop over cells
for _, cell := range o.Cells {
// loop edges of cells
for _, lvids := range cell.Shp.FaceLocalVerts {
// set triple of nodes
tri.a = cell.Verts[lvids[0]]
tri.b = cell.Verts[lvids[1]]
nv := len(lvids)
if nv > 2 {
tri.c = cell.Verts[lvids[2]]
} else {
tri.c = len(o.Verts) + 1 // indicator of not-available
}
utl.IntSort3(&tri.a, &tri.b, &tri.c)
// draw edge if not drawn yet
if _, drawn := edgesdrawn[tri]; !drawn {
x := make([]float64, nv)
y := make([]float64, nv)
x[0] = o.Verts[tri.a].C[0]
y[0] = o.Verts[tri.a].C[1]
if nv == 3 {
x[1] = o.Verts[tri.c].C[0]
y[1] = o.Verts[tri.c].C[1]
x[2] = o.Verts[tri.b].C[0]
y[2] = o.Verts[tri.b].C[1]
} else {
x[1] = o.Verts[tri.b].C[0]
y[1] = o.Verts[tri.b].C[1]
}
plt.Plot(x, y, "'k-o', ms=3, clip_on=0")
edgesdrawn[tri] = true
}
}
// add middle node
if cell.Type == "qua9" {
vid := cell.Verts[8]
x := o.Verts[vid].C[0]
y := o.Verts[vid].C[1]
plt.PlotOne(x, y, "'ko', ms=3, clip_on=0")
}
// linear cells
if strings.HasPrefix(cell.Type, "lin") {
nv := len(cell.Verts)
x := make([]float64, nv)
y := make([]float64, nv)
for i, vid := range cell.Verts {
x[i] = o.Verts[vid].C[0]
y[i] = o.Verts[vid].C[1]
}
plt.Plot(x, y, "'-o', ms=3, clip_on=0, color='#41045a', lw=2")
}
}
// set up
plt.Equal()
plt.AxisRange(o.Xmin, o.Xmax, o.Ymin, o.Ymax)
plt.AxisOff()
}