func plot_cone(α float64, preservePrev bool) { nu, nv := 11, 21 l := 1.2 r := math.Tan(α) * l S, T := utl.MeshGrid2D(0, l, 0, 2.0*PI, nu, nv) X := la.MatAlloc(nv, nu) Y := la.MatAlloc(nv, nu) Z := la.MatAlloc(nv, nu) u := make([]float64, 3) v := make([]float64, 3) L := rot_matrix() for j := 0; j < nu; j++ { for i := 0; i < nv; i++ { u[0] = S[i][j] * r * math.Cos(T[i][j]) u[1] = S[i][j] * r * math.Sin(T[i][j]) u[2] = S[i][j] la.MatVecMul(v, 1, L, u) X[i][j], Y[i][j], Z[i][j] = v[0], v[1], v[2] } } pp := 0 if preservePrev { pp = 1 } plt.Wireframe(X, Y, Z, io.Sf("color='b', lw=0.5, preservePrev=%d", pp)) }
// 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 Test_bezier02(tst *testing.T) { //verbose() chk.PrintTitle("bezier02. quadratic Bezier. point-distance") bez := BezierQuad{ Q: [][]float64{ {-1, 1}, {0.5, -2}, {2, 4}, }, } nx, ny := 5, 5 xx, yy := utl.MeshGrid2D(-1.5, 2.5, -0.5, 4.5, nx, ny) //zz := la.MatAlloc(nx, ny) // TODO: finish this test doplot := false if doplot { plt.SetForPng(1, 400, 200) } C := make([]float64, 2) for j := 0; j < ny; j++ { for i := 0; i < nx; i++ { C[0], C[1] = xx[i][j], yy[i][j] d := bez.DistPoint(C, doplot) io.Pforan("d = %v\n", d) } } np := 21 T := utl.LinSpace(0, 1, np) X := make([]float64, np) Y := make([]float64, np) for i, t := range T { bez.Point(C, t) X[i], Y[i] = C[0], C[1] } if doplot { plt.Plot(X, Y, "'b-', label='Bezier'") plt.Gll("x", "y", "") plt.Equal() plt.SaveD("/tmp", "fig_gm_bezier02.png") } }
func plot_convex(level float64, preservePrev bool) { X, Y := utl.MeshGrid2D(0, 1, 0, 1, NU, NV) Z := la.MatAlloc(NV, NU) for j := 0; j < NU; j++ { for i := 0; i < NV; i++ { Z[i][j] = level - math.Sqrt(X[i][j]) - math.Sqrt(Y[i][j]) if Z[i][j] < -0.01 { Z[i][j] = math.NaN() } } } pp := 0 if preservePrev { pp = 1 } plt.Wireframe(X, Y, Z, io.Sf("color='k', lw=0.5, preservePrev=%d", pp)) }
func plot_sphere(preservePrev bool) { R := 1.0 U, V := utl.MeshGrid2D(0, PI/2.0, 0, PI/2.0, NU, NV) X, Y, Z := la.MatAlloc(NV, NU), la.MatAlloc(NV, NU), la.MatAlloc(NV, NU) for j := 0; j < NU; j++ { for i := 0; i < NV; i++ { X[i][j] = R * math.Cos(U[i][j]) * math.Sin(V[i][j]) Y[i][j] = R * math.Sin(U[i][j]) * math.Sin(V[i][j]) Z[i][j] = R * math.Cos(V[i][j]) } } pp := 0 if preservePrev { pp = 1 } plt.Wireframe(X, Y, Z, io.Sf("color='k', lw=0.5, preservePrev=%d", pp)) }
func plot_superquadric(a, b, c float64, preservePrev bool) { A, B, C := 2.0/a, 2.0/b, 2.0/c R := 1.0 U, V := utl.MeshGrid2D(0, PI/2.0, 0, PI/2.0, NU, NV) X, Y, Z := la.MatAlloc(NV, NU), la.MatAlloc(NV, NU), la.MatAlloc(NV, NU) for j := 0; j < NU; j++ { for i := 0; i < NV; i++ { X[i][j] = R * cosX(U[i][j], A) * sinX(V[i][j], A) Y[i][j] = R * sinX(U[i][j], B) * sinX(V[i][j], B) Z[i][j] = R * cosX(V[i][j], C) } } pp := 0 if preservePrev { pp = 1 } plt.Wireframe(X, Y, Z, io.Sf("color='k', lw=0.5, preservePrev=%d", pp)) }
func CTPplotter(θ, a, b, c, d, e, f1max float64) func() { return func() { np := 401 X, Y := utl.MeshGrid2D(0, 1, 0, f1max, np, np) Z1 := utl.DblsAlloc(np, np) Z2 := utl.DblsAlloc(np, np) sθ, cθ := math.Sin(θ), math.Cos(θ) for j := 0; j < np; j++ { for i := 0; i < np; i++ { f0, f1 := X[i][j], Y[i][j] Z1[i][j] = cθ*(f1-e) - sθ*f0 Z2[i][j] = CTPconstraint(θ, a, b, c, d, e, X[i][j], Y[i][j]) } } plt.Contour(X, Y, Z2, "levels=[0,2],cbar=0,lwd=0.5,fsz=5,cmapidx=6") plt.ContourSimple(X, Y, Z1, false, 7, "linestyles=['--'], linewidths=[0.7], colors=['b'], levels=[0]") } }
func Test_mwicz01(tst *testing.T) { //verbose() chk.PrintTitle("mwicz01. Michalewicz mutation") var ops OpsData ops.SetDefault() ops.Pm = 1.0 ops.Tmax = 10 rnd.Init(0) ops.Xrange = [][]float64{{0, 2}, {1, 3}, {2, 4}, {3, 5}, {4, 6}} T := utl.IntRange(int(ops.Tmax)) for _, t := range T { io.Pf("t=%v Δ=%v\n", t, ops.MwiczDelta(float64(t), 1)) } for _, t := range T { A := []float64{0, 1, 2, 3, 4} FltMutationMwicz(A, t, &ops) io.Pforan("A = %.8f\n", A) } if chk.Verbose { b := 2.0 f := func(r, tb float64) float64 { return math.Pow(r, math.Pow(1.0-tb, b)) } np := 21 r, tb := utl.MeshGrid2D(0, 1, 0, 1, np, np) // tb = t/tmax z := la.MatAlloc(np, np) for i := 0; i < np; i++ { for j := 0; j < np; j++ { z[i][j] = f(r[i][j], tb[i][j]) } } plt.Surface(tb, r, z, "linewidth=0.8") plt.Gll("tb", "r", "") plt.SaveD("/tmp/goga", "test_mwicz01.eps") //plt.Show() } }
func plot_plane(preservePrev bool) { N := []float64{1, 1, 1} // normal P := []float64{0.5, 0, 0} // point on plane d := -N[0]*P[0] - N[1]*P[1] - N[2]*P[2] X, Y := utl.MeshGrid2D(0, 0.5, 0, 0.5, NU, NV) Z := la.MatAlloc(NV, NU) for j := 0; j < NU; j++ { for i := 0; i < NV; i++ { Z[i][j] = (-d - N[0]*X[i][j] - N[1]*Y[i][j]) / N[2] if Z[i][j] < -0.01 { Z[i][j] = math.NaN() } } } pp := 0 if preservePrev { pp = 1 } plt.Wireframe(X, Y, Z, io.Sf("color='k', lw=0.5, preservePrev=%d", pp)) }
// Run computes β starting witn an initial guess func (o *ReliabFORM) Run(βtrial float64, verbose bool, args ...interface{}) (β float64, μ, σ, x []float64) { // initial random variables β = βtrial nx := len(o.μ) μ = make([]float64, nx) // mean values (equivalent normal value) σ = make([]float64, nx) // deviation values (equivalent normal value) x = make([]float64, nx) // current vector of random variables defining min(β) for i := 0; i < nx; i++ { μ[i] = o.μ[i] σ[i] = o.σ[i] x[i] = o.μ[i] } // lognormal distribution structure var lnd DistLogNormal // has lognormal random variable? haslrv := false for _, found := range o.lrv { if found { haslrv = true break } } // function to compute β with x-constant // gβ(β) = g(μ - β・A・σ) = 0 var err error gβfcn := func(fy, y []float64) error { βtmp := y[0] for i := 0; i < nx; i++ { o.xtmp[i] = μ[i] - βtmp*o.α[i]*σ[i] } fy[0], err = o.gfcn(o.xtmp, args) if err != nil { chk.Panic("cannot compute gfcn(%v):\n%v", o.xtmp, err) } return nil } // derivative of gβ w.r.t β hβfcn := func(dfdy [][]float64, y []float64) error { βtmp := y[0] for i := 0; i < nx; i++ { o.xtmp[i] = μ[i] - βtmp*o.α[i]*σ[i] } err = o.hfcn(o.dgdx, o.xtmp, args) if err != nil { chk.Panic("cannot compute hfcn(%v):\n%v", o.xtmp, err) } dfdy[0][0] = 0 for i := 0; i < nx; i++ { dfdy[0][0] -= o.dgdx[i] * o.α[i] * σ[i] } return nil } // nonlinear solver with y[0] = β // solving: gβ(β) = g(μ - β・A・σ) = 0 var nls num.NlSolver nls.Init(1, gβfcn, nil, hβfcn, true, false, nil) defer nls.Clean() // message if verbose { io.Pf("\n%s", io.StrThickLine(60)) } // plotting plot := o.PlotFnk != "" if nx != 2 { plot = false } if plot { if o.PlotNp < 3 { o.PlotNp = 41 } var umin, umax, vmin, vmax float64 if o.PlotCf < 1 { o.PlotCf = 2 } if len(o.PlotUrange) == 0 { umin, umax = μ[0]-o.PlotCf*μ[0], μ[0]+o.PlotCf*μ[0] vmin, vmax = μ[1]-o.PlotCf*μ[1], μ[1]+o.PlotCf*μ[1] } else { chk.IntAssert(len(o.PlotUrange), 2) chk.IntAssert(len(o.PlotVrange), 2) umin, umax = o.PlotUrange[0], o.PlotUrange[1] vmin, vmax = o.PlotVrange[0], o.PlotVrange[1] } o.PlotU, o.PlotV = utl.MeshGrid2D(umin, umax, vmin, vmax, o.PlotNp, o.PlotNp) o.PlotZ = la.MatAlloc(o.PlotNp, o.PlotNp) plt.SetForEps(0.8, 300) for i := 0; i < o.PlotNp; i++ { for j := 0; j < o.PlotNp; j++ { o.xtmp[0] = o.PlotU[i][j] o.xtmp[1] = o.PlotV[i][j] o.PlotZ[i][j], err = o.gfcn(o.xtmp, args) if err != nil { chk.Panic("cannot compute gfcn(%v):\n%v", x, err) } } } plt.Contour(o.PlotU, o.PlotV, o.PlotZ, "") plt.ContourSimple(o.PlotU, o.PlotV, o.PlotZ, true, 8, "levels=[0], colors=['yellow']") plt.PlotOne(x[0], x[1], "'ro', label='initial'") } // iterations to find β var dat VarData B := []float64{β} itB := 0 for itB = 0; itB < o.NmaxItB; itB++ { // message if verbose { gx, err := o.gfcn(x, args) if err != nil { chk.Panic("cannot compute gfcn(%v):\n%v", x, err) } io.Pf("%s itB=%d β=%g g=%g\n", io.StrThinLine(60), itB, β, gx) } // plot if plot { plt.PlotOne(x[0], x[1], "'r.'") } // compute direction cosines itA := 0 for itA = 0; itA < o.NmaxItA; itA++ { // has lognormal random variable (lrv) if haslrv { // find equivalent normal mean and std deviation for lognormal variables for i := 0; i < nx; i++ { if o.lrv[i] { // set distribution dat.M, dat.S = o.μ[i], o.σ[i] lnd.Init(&dat) // update μ and σ fx := lnd.Pdf(x[i]) Φinvx := (math.Log(x[i]) - lnd.M) / lnd.S φx := math.Exp(-Φinvx*Φinvx/2.0) / math.Sqrt2 / math.SqrtPi σ[i] = φx / fx μ[i] = x[i] - Φinvx*σ[i] } } } // compute direction cosines err = o.hfcn(o.dgdx, x, args) if err != nil { chk.Panic("cannot compute hfcn(%v):\n%v", x, err) } den := 0.0 for i := 0; i < nx; i++ { den += math.Pow(o.dgdx[i]*σ[i], 2.0) } den = math.Sqrt(den) αerr := 0.0 // difference on α for i := 0; i < nx; i++ { αnew := o.dgdx[i] * σ[i] / den αerr += math.Pow(αnew-o.α[i], 2.0) o.α[i] = αnew } αerr = math.Sqrt(αerr) // message if verbose { io.Pf(" itA=%d\n", itA) io.Pf("%12s%12s%12s%12s\n", "x", "μ", "σ", "α") for i := 0; i < nx; i++ { io.Pf("%12.3f%12.3f%12.3f%12.3f\n", x[i], μ[i], σ[i], o.α[i]) } } // update x-star for i := 0; i < nx; i++ { x[i] = μ[i] - β*o.α[i]*σ[i] } // check convergence on α if itA > 1 && αerr < o.TolA { if verbose { io.Pfgrey(". . . converged on α with αerr=%g . . .\n", αerr) } break } } // failed to converge on α if itA == o.NmaxItA { chk.Panic("failed to convege on α") } // compute new β B[0] = β nls.Solve(B, o.NlsSilent) βerr := math.Abs(B[0] - β) β = B[0] if o.NlsCheckJ { nls.CheckJ(B, o.NlsCheckJtol, true, false) } // update x-star for i := 0; i < nx; i++ { x[i] = μ[i] - β*o.α[i]*σ[i] } // check convergence on β if βerr < o.TolB { if verbose { io.Pfgrey2(". . . converged on β with βerr=%g . . .\n", βerr) } break } } // failed to converge on β if itB == o.NmaxItB { chk.Panic("failed to converge on β") } // message if verbose { gx, err := o.gfcn(x, args) if err != nil { chk.Panic("cannot compute gfcn(%v):\n%v", x, err) } io.Pfgreen("x = %v\n", x) io.Pfgreen("g = %v\n", gx) io.PfGreen("β = %v\n", β) } // plot if plot { plt.Gll("$x_0$", "$x_1$", "") plt.Cross("") plt.SaveD("/tmp/gosl", "fig_form_"+o.PlotFnk+".eps") } return }
// 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") }
// PlotX plots F and the gradient of F, Gx and Gy, for varying x and fixed t // hlZero -- highlight F(t,x) = 0 // axEqual -- use axis['equal'] func PlotX(o Func, dirout, fname string, tcte float64, xmin, xmax []float64, np int, args string, withGrad, hlZero, axEqual, save, show bool, extra func()) { if len(xmin) == 3 { chk.Panic("PlotX works in 2D only") } X, Y := utl.MeshGrid2D(xmin[0], xmax[0], xmin[1], xmax[1], np, np) F := la.MatAlloc(np, np) var Gx, Gy [][]float64 nrow := 1 if withGrad { Gx = la.MatAlloc(np, np) Gy = la.MatAlloc(np, np) nrow += 1 } x := make([]float64, 2) g := make([]float64, 2) for i := 0; i < np; i++ { for j := 0; j < np; j++ { x[0], x[1] = X[i][j], Y[i][j] F[i][j] = o.F(tcte, x) if withGrad { o.Grad(g, tcte, x) Gx[i][j] = g[0] Gy[i][j] = g[1] } } } prop, wid, dpi := 1.0, 600.0, 200 os.MkdirAll(dirout, 0777) if withGrad { prop = 2 plt.SetForPng(prop, wid, dpi) plt.Subplot(nrow, 1, 1) plt.Title("F(t,x)", "") } else { plt.SetForPng(prop, wid, dpi) } plt.Contour(X, Y, F, args) if hlZero { plt.ContourSimple(X, Y, F, false, 8, "levels=[0], linewidths=[2], colors=['yellow']") } if axEqual { plt.Equal() } if extra != nil { extra() } plt.Gll("x", "y", "") if withGrad { plt.Subplot(2, 1, 2) plt.Title("gradient", "") plt.Quiver(X, Y, Gx, Gy, args) if axEqual { plt.Equal() } plt.Gll("x", "y", "") } if save { plt.Save(dirout + "/" + fname) } if show { plt.Show() } }
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 }
// PlotContour plots contour func (o *Optimiser) PlotContour(iFlt, jFlt, iOva int, pp *PlotParams) { // check var x []float64 if pp.Refx == nil { if iFlt > 1 || jFlt > 1 { chk.Panic("Refx vector must be given to PlotContour when iFlt or jFlt > 1") } x = make([]float64, 2) } else { x = make([]float64, len(pp.Refx)) copy(x, pp.Refx) } // limits and meshgrid xmin, xmax := o.FltMin[iFlt], o.FltMax[iFlt] ymin, ymax := o.FltMin[jFlt], o.FltMax[jFlt] if pp.Xrange != nil { xmin, xmax = pp.Xrange[0], pp.Xrange[1] } if pp.Yrange != nil { ymin, ymax = pp.Yrange[0], pp.Yrange[1] } // check objective function var sol *Solution // copy of solution for objective function if o.MinProb == nil { pp.NoG = true pp.NoH = true sol = NewSolution(o.Nsol, 0, &o.Parameters) o.Solutions[0].CopyInto(sol) if pp.Refx != nil { copy(sol.Flt, pp.Refx) } } // auxiliary variables X, Y := utl.MeshGrid2D(xmin, xmax, ymin, ymax, pp.Npts, pp.Npts) var Zf [][]float64 var Zg [][][]float64 var Zh [][][]float64 var Za [][]float64 if !pp.NoF { Zf = utl.DblsAlloc(pp.Npts, pp.Npts) } if o.Ng > 0 && !pp.NoG { Zg = utl.Deep3alloc(o.Ng, pp.Npts, pp.Npts) } if o.Nh > 0 && !pp.NoH { Zh = utl.Deep3alloc(o.Nh, pp.Npts, pp.Npts) } if pp.WithAux { Za = utl.DblsAlloc(pp.Npts, pp.Npts) } // compute values grp := 0 for i := 0; i < pp.Npts; i++ { for j := 0; j < pp.Npts; j++ { x[iFlt], x[jFlt] = X[i][j], Y[i][j] if o.MinProb == nil { copy(sol.Flt, x) o.ObjFunc(sol, grp) if !pp.NoF { Zf[i][j] = sol.Ova[iOva] } if pp.WithAux { Za[i][j] = sol.Aux } } else { o.MinProb(o.F[grp], o.G[grp], o.H[grp], x, nil, grp) if !pp.NoF { Zf[i][j] = o.F[grp][iOva] } if !pp.NoG { for k, g := range o.G[grp] { Zg[k][i][j] = g } } if !pp.NoH { for k, h := range o.H[grp] { Zh[k][i][j] = h } } } } } // plot f if !pp.NoF && !pp.OnlyAux { txt := "cbar=0" if pp.Cbar { txt = "" } if pp.Simple { plt.ContourSimple(X, Y, Zf, true, 7, io.Sf("colors=['%s'], fsz=7, %s", pp.FmtF.C, txt)) } else { plt.Contour(X, Y, Zf, io.Sf("fsz=7, cmapidx=%d, %s", pp.CmapIdx, txt)) } } // plot g if !pp.NoG && !pp.OnlyAux { for _, g := range Zg { plt.ContourSimple(X, Y, g, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", pp.FmtG.C, pp.FmtG.Lw)) } } // plot h if !pp.NoH && !pp.OnlyAux { for i, h := range Zh { if i == pp.IdxH || pp.IdxH < 0 { plt.ContourSimple(X, Y, h, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", pp.FmtH.C, pp.FmtH.Lw)) } } } // plot aux if pp.WithAux { if pp.OnlyAux { txt := "cbar=0" if pp.Cbar { txt = "" } if pp.Simple { plt.ContourSimple(X, Y, Za, true, 7, io.Sf("colors=['%s'], fsz=7, %s", pp.FmtF.C, txt)) } else { plt.Contour(X, Y, Za, io.Sf("fsz=7, markZero='red', cmapidx=%d, %s", pp.CmapIdx, txt)) } } else { plt.ContourSimple(X, Y, Za, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", pp.FmtA.C, pp.FmtA.Lw)) } } // limits if pp.Limits { plt.Plot( []float64{o.FltMin[iFlt], o.FltMax[iFlt], o.FltMax[iFlt], o.FltMin[iFlt], o.FltMin[iFlt]}, []float64{o.FltMin[jFlt], o.FltMin[jFlt], o.FltMax[jFlt], o.FltMax[jFlt], o.FltMin[jFlt]}, "'y--', color='yellow', zorder=10", ) } }