func Test_dist_frechet_02(tst *testing.T) {
//verbose()
chk.PrintTitle("dist_frechet_02")
doplot := chk.Verbose
if doplot {
plt.SetForEps(1.5, 300)
l := 0.0 // location
C := []float64{1, 2.0} // scale
A := []float64{1, 2, 3} // shape
for _, c := range C {
for _, a := range A {
plot_frechet(l, c, a, 0, 4)
}
}
plt.SaveD("/tmp/gosl", "rnd_dist_frechet_02a.eps")
plt.SetForEps(1.5, 300)
l = 0.5 // location
C = []float64{1, 2.0} // scale
A = []float64{1, 2, 3} // shape
for _, c := range C {
for _, a := range A {
plot_frechet(l, c, a, 0, 4)
}
}
plt.SaveD("/tmp/gosl", "rnd_dist_frechet_02b.eps")
}
}
// PlotTwoNurbs plots two NURBS for comparison
func PlotTwoNurbs(dirout, fn string, b, c *Nurbs, npts int, ids bool, extra func()) {
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 500, 150)
}
plt.Subplot(3, 1, 1)
b.DrawCtrl2d(ids, "", "")
b.DrawElems2d(npts, ids, "", "")
if extra != nil {
extra()
}
plt.Equal()
plt.Subplot(3, 1, 2)
c.DrawCtrl2d(ids, "", "")
c.DrawElems2d(npts, ids, "", "")
plt.Equal()
plt.Subplot(3, 1, 3)
b.DrawElems2d(npts, ids, ", lw=3", "")
c.DrawElems2d(npts, ids, ", color='red', marker='+', markevery=10", "color='green', size=7, va='bottom'")
plt.Equal()
plt.SaveD(dirout, fn)
}
func Test_data3d(tst *testing.T) {
// data
prob := "CF9"
dat := PFdata(prob)
X := utl.DblsGetColumn(0, dat)
Y := utl.DblsGetColumn(1, dat)
Z := utl.DblsGetColumn(2, dat)
// figure
plt.SetForEps(1.0, 400)
plt.Plot3dPoints(X, Y, Z, "s=0.05, color='r', facecolor='r', edgecolor='r', xlbl='$f_1$', ylbl='$f_2$', zlbl='$f_3$'")
plt.AxisRange3d(0, 1, 0, 1, 0, 1)
plt.Camera(10, -135, "")
//plt.Camera(10, 45, "")
plt.SaveD("/tmp/goga", io.Sf("cec09-%s.eps", prob))
// interactive
if false {
r := 0.005
scn := vtk.NewScene()
P := vtk.Spheres{X: X, Y: Y, Z: Z, R: utl.DblVals(len(X), r), Color: []float64{1, 0, 0, 1}}
P.AddTo(scn)
scn.Run()
}
}
// 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() {
// 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 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() {
Nf := []float64{5, 7, 10, 13, 15, 20}
Eave := []float64{3.5998e-12, 2.9629e-10, 6.0300e-8, 3.3686e-6, 2.5914e-5, 1.1966e-3}
plt.SetForEps(0.75, 200)
plt.Plot(Nf, Eave, "'b-', marker='.', clip_on=0")
plt.SetYlog()
plt.Gll("$N_f$", "$E_{ave}$", "")
plt.SaveD("/tmp/goga", "multierror.eps")
}
func Test_bspline01(tst *testing.T) {
//verbose()
chk.PrintTitle("bspline01")
var s1 Bspline
T1 := []float64{0, 0, 0, 1, 1, 1}
s1.Init(T1, 2)
s1.SetControl([][]float64{{0, 0}, {0.5, 1}, {1, 0}})
var s2 Bspline
T2 := []float64{0, 0, 0, 0.5, 1, 1, 1}
s2.Init(T2, 2)
s2.SetControl([][]float64{{0, 0}, {0.25, 0.5}, {0.75, 0.5}, {1, 0}})
if T_BSPLINE_SAVE {
npts := 201
plt.SetForEps(1.5, 500)
plt.SplotGap(0.2, 0.4)
str0 := ",lw=2"
str1 := ",ls='none',marker='+',color='cyan',markevery=10"
str2 := ",ls='none',marker='x',markevery=10"
str3 := ",ls='none',marker='+',markevery=10"
str4 := ",ls='none',marker='4',markevery=10"
plt.Subplot(3, 2, 1)
s1.Draw2D(str0, "", npts, 0) // 0 => CalcBasis
s1.Draw2D(str1, "", npts, 1) // 1 => RecursiveBasis
plt.Subplot(3, 2, 2)
plt.SetAxis(0, 1, 0, 1)
s2.Draw2D(str0, "", npts, 0) // 0 => CalcBasis
s2.Draw2D(str1, "", npts, 1) // 1 => RecursiveBasis
plt.Subplot(3, 2, 3)
s1.PlotBasis("", npts, 0) // 0 => CalcBasis
s1.PlotBasis(str2, npts, 1) // 1 => CalcBasisAndDerivs
s1.PlotBasis(str3, npts, 2) // 2 => RecursiveBasis
plt.Subplot(3, 2, 4)
s2.PlotBasis("", npts, 0) // 0 => CalcBasis
s2.PlotBasis(str2, npts, 1) // 1 => CalcBasisAndDerivs
s2.PlotBasis(str3, npts, 2) // 2 => RecursiveBasis
plt.Subplot(3, 2, 5)
s1.PlotDerivs("", npts, 0) // 0 => CalcBasisAndDerivs
s1.PlotDerivs(str4, npts, 1) // 1 => NumericalDeriv
plt.Subplot(3, 2, 6)
s2.PlotDerivs("", npts, 0) // 0 => CalcBasisAndDerivs
s2.PlotDerivs(str4, npts, 1) // 1 => NumericalDeriv
plt.SaveD("/tmp/gosl", "t_bspline01.eps")
}
}
func Test_igd01(tst *testing.T) {
//verbose()
chk.PrintTitle("igd. igd metric with star equal to trial => igd=0")
// load star values
prob := "UF1"
fStar, err := io.ReadMatrix(io.Sf("./examples/mulobj-cec09/cec09/pf_data/%s.dat", prob))
if err != nil {
tst.Errorf("cannot read fStar matrix:\n%v", err)
return
}
npts := len(fStar)
// optimiser
var opt Optimiser
opt.Default()
opt.Nsol = npts
opt.Ncpu = 1
opt.FltMin = []float64{0, 0} // used to store fStar
opt.FltMax = []float64{1, 1} // used to store fStar
nf, ng, nh := 2, 0, 0
// generator (store fStar into Flt)
gen := func(sols []*Solution, prms *Parameters) {
for i, sol := range sols {
sol.Flt[0], sol.Flt[1] = fStar[i][0], fStar[i][1]
}
}
// objective function (copy fStar from Flt into Ova)
obj := func(f, g, h, x []float64, ξ []int, cpu int) {
f[0], f[1] = x[0], x[1]
}
// initialise optimiser
opt.Init(gen, nil, obj, nf, ng, nh)
// compute igd
igd := StatIgd(&opt, fStar)
io.Pforan("igd = %v\n", igd)
chk.Scalar(tst, "igd", 1e-15, igd, 0)
// plot
if chk.Verbose {
fmt := &plt.Fmt{C: "red", M: ".", Ms: 1, Ls: "None", L: "solutions"}
fS0 := utl.DblsGetColumn(0, fStar)
fS1 := utl.DblsGetColumn(1, fStar)
io.Pforan("len(fS0) = %v\n", len(fS0))
plt.SetForEps(0.75, 300)
opt.PlotAddOvaOva(0, 1, opt.Solutions, true, fmt)
plt.Plot(fS0, fS1, io.Sf("'b.', ms=2, label='star(%s)', clip_on=0", prob))
plt.Gll("$f_0$", "$f_1$", "")
plt.SaveD("/tmp/goga", "igd01.eps")
}
}
func Test_data2d(tst *testing.T) {
prob := "CF4"
dat := PFdata(prob)
X := utl.DblsGetColumn(0, dat)
Y := utl.DblsGetColumn(1, dat)
plt.SetForEps(1.0, 250)
plt.Plot(X, Y, "'r.'")
plt.Gll("$f_1$", "$f_2$", "")
plt.SaveD("/tmp/goga", io.Sf("cec09-%s.eps", prob))
}
// PlotNurbsBasis plots basis functions la and lb
func PlotNurbsBasis(dirout, fn string, b *Nurbs, la, lb int) {
npts := 41
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 600, 150)
}
plt.Subplot(3, 2, 1)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
t0 := time.Now()
b.PlotBasis(la, "", 11, 0) // 0 => CalcBasis
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(3, 2, 2)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(lb, "", 11, 0) // 0 => CalcBasis
plt.Equal()
plt.Subplot(3, 2, 3)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(la, "", 11, 1) // 1 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(3, 2, 4)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(lb, "", 11, 1) // 1 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(3, 2, 5)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
t0 = time.Now()
b.PlotBasis(la, "", 11, 2) // 2 => RecursiveBasis
io.Pfcyan("time elapsed (recursive) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(3, 2, 6)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(lb, "", 11, 2) // 2 => RecursiveBasis
plt.Equal()
plt.SaveD(dirout, fn)
}
func Test_dist_uniform_02(tst *testing.T) {
//verbose()
chk.PrintTitle("dist_uniform_02")
doplot := chk.Verbose
if doplot {
plt.SetForEps(1.5, 300)
A := 1.5 // min
B := 2.5 // max
plot_uniform(A, B, 1.0, 3.0)
plt.SaveD("/tmp/gosl", "rnd_dist_uniform_02a.eps")
}
}
func Test_norm02(tst *testing.T) {
//verbose()
chk.PrintTitle("norm02")
doplot := chk.Verbose
if doplot {
plt.SetForEps(1.5, 300)
for _, σ := range []float64{1, 0.5, 0.25} {
plot_normal(0, σ)
}
plt.SaveD("/tmp/gosl", "test_norm02.eps")
}
}
func Test_gev02(tst *testing.T) {
//verbose()
chk.PrintTitle("gev02")
doplot := chk.Verbose
if doplot {
plt.SetForEps(1.5, 300)
for _, ξ := range []float64{0.5, -0.5, 0} {
plot_gev(0, 1, ξ)
}
plt.SaveD("/tmp/gosl", "test_gev02.eps")
}
}
// PlotNurbs plots a NURBS
func PlotNurbs(dirout, fn string, b *Nurbs, npts int, ids bool, extra func()) {
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.0, 500)
} else {
plt.SetForPng(1.0, 500, 150)
}
b.DrawCtrl2d(ids, "", "")
b.DrawElems2d(npts, ids, "", "")
if extra != nil {
extra()
}
plt.Equal()
plt.SaveD(dirout, fn)
}
func Test_bspline02(tst *testing.T) {
//verbose()
chk.PrintTitle("bspline02")
// 0 1 2 3 4 5 6 7 8 9 10
T := []float64{0, 0, 0, 1, 2, 3, 4, 4, 5, 5, 5}
sol := []int{2, 2, 3, 3, 4, 4, 5, 5, 7, 7, 7}
var s Bspline
s.Init(T, 2)
s.SetControl([][]float64{{0, 0}, {0.5, 1}, {1, 0}, {1.5, 0}, {2, 1}, {2.5, 1}, {3, 0.5}, {3.5, 0}})
tt := utl.LinSpace(0, 5, 11)
for k, t := range tt {
span := s.find_span(t)
io.Pforan("t=%.4f => span=%v\n", t, span)
if span != sol[k] {
chk.Panic("find_span failed: t=%v span => %d != %d", t, span, sol[k])
}
}
tol := 1e-14
np := len(tt)
xx, yy := make([]float64, np), make([]float64, np)
for k, t := range tt {
t0 := time.Now()
pa := s.Point(t, 0) // 0 => CalcBasis
io.Pf("Point(rec): dtime = %v\n", time.Now().Sub(t0))
t0 = time.Now()
pb := s.Point(t, 1) // 1 => RecursiveBasis
io.Pf("Point: dtime = %v\n", time.Now().Sub(t0))
xx[k], yy[k] = pb[0], pb[1]
io.Pfred("pa - pb = %v, %v\n", pa[0]-pb[0], pa[1]-pb[1])
chk.Vector(tst, "Point", tol, pa, pb)
}
if T_BSPLINE_SAVE {
npts := 201
plt.SetForEps(0.75, 300)
str0 := ",lw=2"
str1 := ",ls='none',marker='+',color='cyan',markevery=10"
s.Draw2D(str0, "", npts, 0) // 0 => CalcBasis
s.Draw2D(str1, "", npts, 1) // 1 => RecursiveBasis
plt.Plot(xx, yy, "'bo', clip_on=0")
plt.SaveD("/tmp/gosl", "t_bspline02.eps")
}
}
// PlotNurbsDerivs plots derivatives of basis functions la and lb
func PlotNurbsDerivs(dirout, fn string, b *Nurbs, la, lb int) {
npts := 41
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 600, 150)
}
plt.Subplot(4, 2, 1)
t0 := time.Now()
b.PlotDeriv(la, 0, "", npts, 0) // 0 => CalcBasisAndDerivs
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(4, 2, 2)
t0 = time.Now()
b.PlotDeriv(la, 0, "", npts, 1) // 1 => NumericalDeriv
io.Pfcyan("time elapsed (numerical) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(4, 2, 3)
b.PlotDeriv(la, 1, "", npts, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 4)
b.PlotDeriv(la, 1, "", npts, 1) // 0 => NumericalDeriv
plt.Equal()
plt.Subplot(4, 2, 5)
b.PlotDeriv(lb, 0, "", npts, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 6)
b.PlotDeriv(lb, 0, "", npts, 1) // 0 => NumericalDeriv
plt.Equal()
plt.Subplot(4, 2, 7)
b.PlotDeriv(lb, 1, "", npts, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 8)
b.PlotDeriv(lb, 1, "", npts, 1) // 0 => NumericalDeriv
plt.Equal()
plt.SaveD(dirout, fn)
}
func Test_flt03(tst *testing.T) {
//verbose()
chk.PrintTitle("flt03. circle with equality constraint")
// geometry
xe := 1.0 // centre of circle
le := -0.4 // selected level of f(x)
ys := xe - (1.0+le)/math.Sqrt2 // coordinates of minimum point with level=le
y0 := 2.0*ys + xe // vertical axis intersect of straight line defined by c(x)
xc := []float64{xe, xe} // centre
// parameters
var opt Optimiser
opt.Default()
opt.Nsol = 20
opt.Ncpu = 1
opt.Verbose = false
opt.FltMin = []float64{-1, -1}
opt.FltMax = []float64{3, 3}
nf, ng, nh := 1, 0, 1
// initialise optimiser
opt.Init(GenTrialSolutions, nil, func(f, g, h, x []float64, ξ []int, cpu int) {
res := 0.0
for i := 0; i < len(x); i++ {
res += (x[i] - xc[i]) * (x[i] - xc[i])
}
f[0] = math.Sqrt(res) - 1.0
h[0] = x[0] + x[1] + xe - y0
}, nf, ng, nh)
// initial solutions
sols0 := opt.GetSolutionsCopy()
// solve
opt.Solve()
// plot
if chk.Verbose {
pp := NewPlotParams(false)
pp.FnKey = "fig-flt03"
pp.AxEqual = true
plt.SetForEps(1, 400)
opt.PlotFltFltContour(sols0, 0, 1, 0, pp)
}
}
func main() {
// default input data
fn := "nurbs01.msh"
ctrl := true
ids := true
npts := 41
// parse flags
flag.Parse()
if len(flag.Args()) > 0 {
fn = flag.Arg(0)
}
if len(flag.Args()) > 1 {
ctrl = io.Atob(flag.Arg(1))
}
if len(flag.Args()) > 2 {
ids = io.Atob(flag.Arg(2))
}
if len(flag.Args()) > 3 {
npts = io.Atoi(flag.Arg(3))
}
// print input data
io.Pforan("Input data\n")
io.Pforan("==========\n")
io.Pfblue2(" fn = %v\n", fn)
io.Pfblue2(" ctrl = %v\n", ctrl)
io.Pfblue2(" ids = %v\n", ids)
io.Pfblue2(" npts = %v\n", npts)
// load nurbss
fnk := io.FnKey(fn)
B := gm.ReadMsh(fnk)
// plot
plt.SetForEps(0.75, 500)
for _, b := range B {
if ctrl {
b.DrawCtrl2d(ids, "", "")
}
b.DrawElems2d(npts, ids, "", "")
}
plt.Equal()
plt.Save(fnk + ".eps")
}
func Test_dist_lognormal_03(tst *testing.T) {
//verbose()
chk.PrintTitle("dist_lognormal_03. random numbers")
μ := 1.0
σ := 0.25
nsamples := 1000
X := make([]float64, nsamples)
for i := 0; i < nsamples; i++ {
X[i] = Lognormal(μ, σ)
}
nstations := 41
xmin := 0.0
xmax := 3.0
dx := (xmax - xmin) / float64(nstations-1)
var hist Histogram
hist.Stations = utl.LinSpace(xmin, xmax, nstations)
hist.Count(X, true)
prob := make([]float64, nstations)
for i := 0; i < nstations-1; i++ {
prob[i] = float64(hist.Counts[i]) / (float64(nsamples) * dx)
}
io.Pf(TextHist(hist.GenLabels("%.3f"), hist.Counts, 60))
io.Pforan("dx = %v\n", dx)
area := 0.0
for i := 0; i < nstations-1; i++ {
area += dx * prob[i]
}
io.Pforan("area = %v\n", area)
chk.Scalar(tst, "area", 1e-15, area, 1)
if chk.Verbose {
plt.SetForEps(1.5, 300)
plot_lognormal(μ, σ)
plt.Subplot(2, 1, 1)
hist.PlotDensity(nil, "")
plt.SaveD("/tmp/gosl", "rnd_dist_lognormal_03.eps")
}
}
func do_plot_nurbs_refined(b, c *Nurbs) {
plt.SetForEps(1.5, 400)
plt.Subplot(3, 1, 1)
b.DrawCtrl2D(true)
b.DrawElems2D(21, true, "", "")
plt.Equal()
plt.Subplot(3, 1, 2)
c.DrawCtrl2D(true)
c.DrawElems2D(21, true, "", "")
plt.Equal()
plt.Subplot(3, 1, 3)
b.DrawElems2D(21, true, ", lw=3", "")
c.DrawElems2D(21, true, ", color='red', marker='+', markevery=10", "color='magenta', size=8, va='bottom'")
plt.Equal()
}
func Test_halton01(tst *testing.T) {
//verbose()
chk.PrintTitle("halton01. Halton Points")
dim := 2
npts := 100
P := HaltonPoints(dim, npts)
X := P[0]
Y := P[1]
if chk.Verbose {
plt.SetForEps(1, 400)
plt.Plot(X, Y, "'r.', clip_on=0")
plt.Equal()
plt.SaveD("/tmp/gosl", "halton01.eps")
}
}
func Test_dist_lognormal_02(tst *testing.T) {
//verbose()
chk.PrintTitle("dist_lognormal_02")
doplot := chk.Verbose
if doplot {
plt.SetForEps(1.5, 300)
n := 0.0
for _, z := range []float64{1, 0.5, 0.25} {
w := z * z
μ := math.Exp(n + w/2.0)
σ := μ * math.Sqrt(math.Exp(w)-1.0)
plot_lognormal(μ, σ)
}
plt.SaveD("/tmp/gosl", "rnd_dist_lognormal_02.eps")
}
}
func Test_dist_gumbel_02(tst *testing.T) {
//verbose()
chk.PrintTitle("dist_gumbel_02")
doplot := chk.Verbose
if doplot {
plt.SetForEps(1.5, 300)
U := []float64{1.5, 1.0, 0.5, 3.0}
B := []float64{3.0, 2.0, 2.0, 4.0}
for i, u := range U {
σ := B[i] * math.Pi / math.Sqrt(6.0)
μ := u + EULER*B[i]
plot_gumbel(μ, σ)
}
plt.SaveD("/tmp/gosl", "rnd_dist_gumbel_02.eps")
}
}
// SetFig sets figure space for plotting
// Note: this method is optional
func (o *Plotter) SetFig(split, epsfig bool, prop, width float64, savedir, savefnk string) {
plt.Reset()
if o.PngRes < 150 {
o.PngRes = 150
}
o.Split = split
o.UseEps = epsfig
if o.UseEps {
plt.SetForEps(prop, width)
} else {
plt.SetForPng(prop, width, o.PngRes)
}
o.SaveDir = savedir
o.SaveFnk = io.FnKey(savefnk)
o.maxR = -1
// colors and markers
o.set_default_clr_mrk()
}
func do_plot_nurbs_basis(b *Nurbs, la, lb int) {
npts := 21
plt.SetForEps(1.2, 500)
plt.Subplot(3, 2, 1)
b.DrawCtrl2D(false)
b.DrawElems2D(npts, false, "", "")
t0 := time.Now()
b.PlotBasis(la, "", 11, 0) // 0 => CalcBasis
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(3, 2, 2)
b.DrawCtrl2D(false)
b.DrawElems2D(npts, false, "", "")
b.PlotBasis(lb, "", 11, 0) // 0 => CalcBasis
plt.Equal()
plt.Subplot(3, 2, 3)
b.DrawCtrl2D(false)
b.DrawElems2D(npts, false, "", "")
b.PlotBasis(la, "", 11, 1) // 1 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(3, 2, 4)
b.DrawCtrl2D(false)
b.DrawElems2D(npts, false, "", "")
b.PlotBasis(lb, "", 11, 1) // 1 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(3, 2, 5)
b.DrawCtrl2D(false)
b.DrawElems2D(npts, false, "", "")
t0 = time.Now()
b.PlotBasis(la, "", 11, 2) // 2 => RecursiveBasis
io.Pfcyan("time elapsed (recursive) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(3, 2, 6)
b.DrawCtrl2D(false)
b.DrawElems2D(npts, false, "", "")
b.PlotBasis(lb, "", 11, 2) // 2 => RecursiveBasis
plt.Equal()
}
// PlotHc2d plots 2D hypercube
func PlotHc2d(dirout, fnkey string, x [][]int, xrange [][]float64) {
m := len(x)
n := len(x[0])
dx := make([]float64, m)
for i := 0; i < m; i++ {
dx[i] = (xrange[i][1] - xrange[i][0]) / float64(n-1)
}
X := utl.DblsAlloc(m, n)
for i := 0; i < m; i++ {
for j := 0; j < n; j++ {
X[i][j] = xrange[i][0] + float64(x[i][j]-1)*dx[i]
}
}
plt.SetForEps(0.8, 300)
plt.Plot(X[0], X[1], "'r.', clip_on=0, zorder=10")
plt.Equal()
plt.Gll("$x$", "$y$", "")
plt.SaveD(dirout, fnkey+".eps")
}
func py_plot3(iOva, jOva, kOva int, opt *goga.Optimiser, plot_solution func(), onlyFront0, twice bool) {
// results
var X, Y, Z []float64
if onlyFront0 {
for _, sol := range opt.Solutions {
if sol.Feasible() && sol.FrontId == 0 {
X = append(X, sol.Ova[iOva])
Y = append(Y, sol.Ova[jOva])
Z = append(Z, sol.Ova[kOva])
}
}
} else {
X, Y, Z = make([]float64, opt.Nsol), make([]float64, opt.Nsol), make([]float64, opt.Nsol)
for i, sol := range opt.Solutions {
X[i], Y[i], Z[i] = sol.Ova[iOva], sol.Ova[jOva], sol.Ova[kOva]
}
}
// plot
plt.SetForEps(1.0, 400)
plot_solution()
plt.Plot3dPoints(X, Y, Z, "s=7, color='r', facecolor='r', edgecolor='r', preservePrev=1, xlbl='$f_0$', ylbl='$f_1$', zlbl='$f_2$'")
e, a := 10.0, 45.0
if opt.RptName == "DTLZ2c" {
e, a = 15, 30
}
//plt.Camera(e, a, "")
//plt.AxDist(11.0)
//plt.AxisRange3d(opt.RptFmin[iOva], opt.RptFmax[iOva], opt.RptFmin[jOva], opt.RptFmax[jOva], opt.RptFmin[kOva], opt.RptFmax[kOva])
//plt.SaveD("/tmp/goga", io.Sf("py_%s_A.eps", opt.RptName))
if twice {
e, a = 10, -45
if opt.RptName == "DTLZ2c" {
e, a = 10, -45
}
plt.Camera(e, a, "")
plt.AxDist(11.0)
plt.AxisRange3d(opt.RptFmin[iOva], opt.RptFmax[iOva], opt.RptFmin[jOva], opt.RptFmax[jOva], opt.RptFmin[kOva], opt.RptFmax[kOva])
plt.SaveD("/tmp/goga", io.Sf("py_%s_B.eps", opt.RptName))
}
}
func main() {
nsol := 500
tf := 1000
time := []float64{
223.42398255, // 1
82.864179318, // 2
50.945049948, // 3
29.547849719, // 4
20.741909766, // 5
17.188611472, // 6
15.937424833, // 7
13.919150335, // 8
12.589523593, // 9
12.078978314, // 10
11.034417259, // 11
9.542071936, // 12
9.298965819, // 13
9.182769212, // 14
8.610938487, // 15
8.482685187, // 16
}
ncpu := utl.LinSpace(1, 16, 16)
speedup := make([]float64, 16)
speedup[0] = 1
for i := 1; i < 16; i++ {
speedup[i] = time[0] / time[i] // Told / Tnew
}
io.Pforan("ncpu = %v\n", ncpu)
plt.SetForEps(0.75, 250)
plt.Plot(ncpu, speedup, io.Sf("'b-',marker='.', label='speedup: $N_{sol}=%d,\\,t_f=%d$', clip_on=0, zorder=100", nsol, tf))
plt.Plot([]float64{1, 16}, []float64{1, 16}, "'k--',zorder=50")
plt.Gll("$N_{cpu}:\\;$ number of groups", "speedup", "")
plt.DoubleYscale("$T_{sys}:\\;$ system time [s]")
plt.Plot(ncpu, time, "'k-',color='gray', clip_on=0")
plt.SaveD("/tmp/goga", "topology-speedup.eps")
}
func do_plot_nurbs_derivs(b *Nurbs, la, lb int) {
np := 11
plt.SetForEps(1.5, 500)
plt.Subplot(4, 2, 1)
t0 := time.Now()
b.PlotDeriv(la, 0, "", np, 0) // 0 => CalcBasisAndDerivs
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(4, 2, 2)
t0 = time.Now()
b.PlotDeriv(la, 0, "", np, 1) // 1 => NumericalDeriv
io.Pfcyan("time elapsed (numerical) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(4, 2, 3)
b.PlotDeriv(la, 1, "", np, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 4)
b.PlotDeriv(la, 1, "", np, 1) // 0 => NumericalDeriv
plt.Equal()
plt.Subplot(4, 2, 5)
b.PlotDeriv(lb, 0, "", np, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 6)
b.PlotDeriv(lb, 0, "", np, 1) // 0 => NumericalDeriv
plt.Equal()
plt.Subplot(4, 2, 7)
b.PlotDeriv(lb, 1, "", np, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 8)
b.PlotDeriv(lb, 1, "", np, 1) // 0 => NumericalDeriv
plt.Equal()
}