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")
}
}
// PlotFltOva plots flt-ova points
func (o *Optimiser) PlotFltOva(sols0 []*Solution, iFlt, iOva int, ovaMult float64, pp *PlotParams) {
if pp.YfuncX != nil {
X := utl.LinSpace(o.FltMin[iFlt], o.FltMax[iFlt], pp.NptsYfX)
Y := make([]float64, pp.NptsYfX)
for i := 0; i < pp.NptsYfX; i++ {
Y[i] = pp.YfuncX(X[i])
}
plt.Plot(X, Y, pp.FmtYfX.GetArgs(""))
}
if sols0 != nil {
o.PlotAddFltOva(iFlt, iOva, sols0, ovaMult, &pp.FmtSols0)
}
o.PlotAddFltOva(iFlt, iOva, o.Solutions, ovaMult, &pp.FmtSols)
best, _ := GetBestFeasible(o, iOva)
if best != nil {
plt.PlotOne(best.Flt[iFlt], best.Ova[iOva]*ovaMult, pp.FmtBest.GetArgs(""))
}
if pp.Extra != nil {
pp.Extra()
}
if pp.AxEqual {
plt.Equal()
}
plt.Gll(io.Sf("$x_{%d}$", iFlt), io.Sf("$f_{%d}$", iOva), "leg_out=1, leg_ncol=4, leg_hlen=1.5")
plt.SaveD(pp.DirOut, pp.FnKey+pp.FnExt)
}
// 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_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")
}
}
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()
}
}
func main() {
// filename
filename, fnkey := io.ArgToFilename(0, "sg111", ".sim", true)
// fem
if !fem.Start(filename, false, false, false) {
io.PfRed("Start failed\n")
return
}
dom, sum, ok := fem.AllocSetAndInit(0, true, true)
if !ok {
io.PfRed("AllocSetAndInit failed\n")
return
}
// selected node and dof index
nidx := 1
didx := 1
// gofem
ntout := len(sum.OutTimes)
uy := make([]float64, ntout)
for tidx, _ := range sum.OutTimes {
// read results from file
if !dom.In(sum, tidx, true) {
io.PfRed("plot_spo751: cannot read solution\n")
return
}
// collect results for load versus time plot
nod := dom.Nodes[nidx]
eq := nod.Dofs[didx].Eq
uy[tidx] = dom.Sol.Y[eq]
// check
if math.Abs(dom.Sol.T-sum.OutTimes[tidx]) > 1e-14 {
io.PfRed("output times do not match time in solution array\n")
return
}
}
// plot fem results
plt.SetForPng(0.8, 400, 200)
plt.Plot(sum.OutTimes, uy, "'ro-', clip_on=0, label='gofem'")
// analytical solution
tAna := utl.LinSpace(0, 5, 101)
uyAna := make([]float64, len(tAna))
for i, t := range tAna {
uyAna[i] = solution_uy(t, 1.0)
}
plt.Plot(tAna, uyAna, "'g-', clip_on=0, label='analytical'")
// save
plt.Gll("$t$", "$u_y$", "")
plt.SaveD("/tmp", fnkey+".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() {
// 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() {
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_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_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 chk.Verbose {
npts := 201
plt.SetForPng(1.5, 600, 150)
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/gm", "bspline01.png")
}
}
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))
}
func Test_bins02(tst *testing.T) {
//verbose()
chk.PrintTitle("bins02. find along line (2D)")
// bins
var bins Bins
bins.Init([]float64{-0.2, -0.2}, []float64{0.8, 1.8}, 5)
// fill bins structure
maxit := 5 // number of entries
ID := make([]int, maxit)
for k := 0; k < maxit; k++ {
x := float64(k) / float64(maxit)
ID[k] = k
err := bins.Append([]float64{x, 2*x + 0.2}, ID[k])
if err != nil {
chk.Panic(err.Error())
}
}
// add more points to bins
for i := 0; i < 5; i++ {
err := bins.Append([]float64{float64(i) * 0.1, 1.8}, 100+i)
if err != nil {
chk.Panic(err.Error())
}
}
// message
for _, bin := range bins.All {
if bin != nil {
io.Pf("%v\n", bin)
}
}
// find points along diagonal
ids := bins.FindAlongSegment([]float64{0.0, 0.2}, []float64{0.8, 1.8}, 1e-8)
io.Pforan("ids = %v\n", ids)
chk.Ints(tst, "ids", ids, ID)
// find additional points
ids = bins.FindAlongSegment([]float64{-0.2, 1.8}, []float64{0.8, 1.8}, 1e-8)
io.Pfcyan("ids = %v\n", ids)
chk.Ints(tst, "ids", ids, []int{100, 101, 102, 103, 104, 4})
// draw
if chk.Verbose {
plt.SetForPng(1, 500, 150)
bins.Draw2d(true, true, true, true, map[int]bool{8: true, 9: true, 10: true})
plt.SetXnticks(15)
plt.SetYnticks(15)
plt.SaveD("/tmp/gosl/gm", "test_bins02.png")
}
}
func savefig(dirout, fnk, ext string, idx int) {
fn := fnk + ext
if idx >= 0 {
fn = io.Sf("%s_%d%s", fnk, idx, ext)
}
if dirout == "" {
plt.Save(fn)
} else {
plt.SaveD(dirout, fn)
}
}
func main() {
// filename
filename, fnkey := io.ArgToFilename(0, "rjoint01", ".sim", true)
// fem
if !fem.Start(filename, false, false, false) {
io.PfRed("Start failed\n")
return
}
dom, sum, ok := fem.AllocSetAndInit(0, true, true)
if !ok {
io.PfRed("AllocSetAndInit failed\n")
return
}
// rjoint element
eid := 2
ele := dom.Elems[eid].(*fem.Rjoint)
ipd := ele.OutIpsData()
// load results from file
n := len(sum.OutTimes)
mtau0 := make([]float64, n)
mtau1 := make([]float64, n)
mtau2 := make([]float64, n)
ompb0 := make([]float64, n)
ompb1 := make([]float64, n)
ompb2 := make([]float64, n)
for i, _ := range sum.OutTimes {
if !dom.In(sum, i, true) {
io.PfRed("cannot read solution\n")
return
}
res0 := ipd[0].Calc(dom.Sol)
res1 := ipd[1].Calc(dom.Sol)
res2 := ipd[2].Calc(dom.Sol)
mtau0[i] = -res0["tau"]
mtau1[i] = -res1["tau"]
mtau2[i] = -res2["tau"]
ompb0[i] = res0["ompb"]
ompb1[i] = res1["ompb"]
ompb2[i] = res2["ompb"]
}
// plot
plt.SetForPng(0.8, 400, 200)
plt.Plot(ompb0, mtau0, "'r-', marker='.', label='p0', clip_on=0")
plt.Plot(ompb1, mtau1, "'g-', marker='.', label='p1', clip_on=0")
plt.Plot(ompb2, mtau2, "'b-', marker='.', label='p2', clip_on=0")
plt.Gll("$\\bar{\\omega}_p$", "$-\\tau$", "")
plt.SaveD("/tmp", fnkey+".png")
}
// PlotFltFlt plots flt-flt contour
// use iFlt==-1 || jFlt==-1 to plot all combinations
func (o *Optimiser) PlotFltFltContour(sols0 []*Solution, iFlt, jFlt, iOva int, pp *PlotParams) {
best, _ := GetBestFeasible(o, iOva)
plotAll := iFlt < 0 || jFlt < 0
plotCommands := func(i, j int) {
o.PlotContour(i, j, iOva, pp)
if sols0 != nil {
o.PlotAddFltFlt(i, j, sols0, &pp.FmtSols0)
}
o.PlotAddFltFlt(i, j, o.Solutions, &pp.FmtSols)
if best != nil {
plt.PlotOne(best.Flt[i], best.Flt[j], pp.FmtBest.GetArgs(""))
}
if pp.Extra != nil {
pp.Extra()
}
if pp.AxEqual {
plt.Equal()
}
}
if plotAll {
idx := 1
ncol := o.Nflt - 1
for row := 0; row < o.Nflt; row++ {
idx += row
for col := row + 1; col < o.Nflt; col++ {
plt.Subplot(ncol, ncol, idx)
plt.SplotGap(0.0, 0.0)
plotCommands(col, row)
if col > row+1 {
plt.SetXnticks(0)
plt.SetYnticks(0)
} else {
plt.Gll(io.Sf("$x_{%d}$", col), io.Sf("$x_{%d}$", row), "leg=0")
}
idx++
}
}
idx = ncol*(ncol-1) + 1
plt.Subplot(ncol, ncol, idx)
plt.AxisOff()
// TODO: fix formatting of open marker, add star to legend
plt.DrawLegend([]plt.Fmt{pp.FmtSols0, pp.FmtSols, pp.FmtBest}, 8, "center", false, "")
} else {
plotCommands(iFlt, jFlt)
if pp.Xlabel == "" {
plt.Gll(io.Sf("$x_{%d}$", iFlt), io.Sf("$x_{%d}$", jFlt), pp.LegPrms)
} else {
plt.Gll(pp.Xlabel, pp.Ylabel, pp.LegPrms)
}
}
plt.SaveD(pp.DirOut, pp.FnKey+pp.FnExt)
}
func plot2(opt *goga.Optimiser, onlyFront0 bool) {
// plot reference values
f0 := utl.DblsGetColumn(0, opt.Multi_fStar)
f1 := utl.DblsGetColumn(1, opt.Multi_fStar)
plt.Plot(f0, f1, "'b-', label='reference'")
// plot goga values
fmt := &plt.Fmt{C: "r", M: "o", Ms: 3, L: "goga", Ls: "None"}
opt.PlotAddOvaOva(0, 1, opt.Solutions, true, fmt)
plt.Gll("$f_0$", "$f_1$", "")
plt.SaveD("/tmp/goga", io.Sf("m2_%s.eps", opt.RptName))
}
func Test_nurbs02(tst *testing.T) {
//verbose()
chk.PrintTitle("nurbs02")
b := get_nurbs_A()
do_check_derivs(tst, b, 11, 1e-5, false)
if T_NURBS_SAVE {
do_plot_nurbs_derivs(b, 0, 7)
plt.SaveD("/tmp/gosl", "t_nurbs02.eps")
}
}
// 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_invs05(tst *testing.T) {
//verbose()
chk.PrintTitle("invs05")
if SAVEPLOT {
plt.Reset()
plt.SetForPng(1, 500, 125)
PlotRosette(1.1, true, true, true, 7)
}
addtoplot := func(σa, σb float64, σ []float64) {
plt.PlotOne(σa, σb, "'ro', ms=5")
plt.Text(σa, σb, io.Sf("$\\sigma_{123}=(%g,%g,%g)$", σ[0], σ[1], σ[2]), "size=8")
}
dotest := func(σ []float64, σacor, σbcor, σccor, θcor, tolσ float64) {
w := M_w(σ)
θ2 := math.Asin(w) * 180.0 / (3.0 * math.Pi)
θ3 := M_θ(σ)
σa, σb, σc := L2O(σ[0], σ[1], σ[2])
σ0, σ1, σ2 := O2L(σa, σb, σc)
σI, σA := make([]float64, 3), []float64{σa, σb, σc}
la.MatVecMul(σI, 1, O2Lmat(), σA) // σI := L * σA
io.Pf("σa σb σc = %v %v %v\n", σa, σb, σc)
io.Pf("w = %v\n", w)
io.Pf("θ2, θ3 = %v, %v\n", θ2, θ3)
chk.Scalar(tst, "σa", 1e-17, σa, σacor)
chk.Scalar(tst, "σb", 1e-17, σb, σbcor)
chk.Scalar(tst, "σc", 1e-17, σc, σccor)
chk.Scalar(tst, "σ0", tolσ, σ0, σ[0])
chk.Scalar(tst, "σ1", tolσ, σ1, σ[1])
chk.Scalar(tst, "σ2", tolσ, σ2, σ[2])
chk.Scalar(tst, "σI0", tolσ, σI[0], σ[0])
chk.Scalar(tst, "σI1", tolσ, σI[1], σ[1])
chk.Scalar(tst, "σI2", tolσ, σI[2], σ[2])
chk.Scalar(tst, "θ2", 1e-6, θ2, θcor)
chk.Scalar(tst, "θ3", 1e-17, θ3, θ2)
addtoplot(σa, σb, σ)
}
dotest([]float64{-1, 0, 0, 0}, 0, 2.0/SQ6, 1.0/SQ3, 30, 1e-15)
dotest([]float64{0, -1, 0, 0}, 1.0/SQ2, -1.0/SQ6, 1.0/SQ3, 30, 1e-15)
dotest([]float64{0, 0, -1, 0}, -1.0/SQ2, -1.0/SQ6, 1.0/SQ3, 30, 1e-15)
if SAVEPLOT {
plt.Gll("$\\sigma_a$", "$\\sigma_b$", "")
plt.Equal()
plt.SaveD("/tmp/gosl", "fig_invs05.png")
}
}
// Plot plot results
func Plot(dirout, fn string, res *Results, yfcn Cb_ycorr, xa, xb float64, argsAna, argsNum string, extra func()) {
// data
if res == nil {
return
}
ndim := len(res.Y)
if ndim < 1 {
return
}
// closed-form solution
var xc []float64
var Yc [][]float64
if yfcn != nil {
np := 101
dx := (xb - xa) / float64(np-1)
xc = make([]float64, np)
Yc = utl.DblsAlloc(np, ndim)
for i := 0; i < np; i++ {
xc[i] = xa + dx*float64(i)
yfcn(Yc[i], xc[i])
}
}
// plot
if argsAna == "" {
argsAna = "'y-', lw=6, label='analytical', clip_on=0"
}
if argsNum == "" {
argsNum = "'b-', marker='.', lw=1, clip_on=0"
}
for j := 0; j < ndim; j++ {
plt.Subplot(ndim+1, 1, j+1)
if yfcn != nil {
plt.Plot(xc, Yc[j], argsAna)
}
plt.Plot(res.X, res.Y[j], argsNum+","+io.Sf("label='%s'", res.Method))
plt.Gll("$x$", "$y$", "")
}
plt.Subplot(ndim+1, 1, ndim+1)
plt.Plot(res.X, res.Dx, io.Sf("'b-', marker='.', lw=1, clip_on=0, label='%s'", res.Method))
plt.SetYlog()
plt.Gll("$x$", "$\\log(\\delta x)$", "")
// write file
if extra != nil {
extra()
}
plt.SaveD(dirout, fn)
}
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_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_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")
}
}
func Test_nurbs03(tst *testing.T) {
//verbose()
chk.PrintTitle("nurbs03")
b := get_nurbs_B()
if T_NURBS_SAVE {
la := 0 + 0*b.n[0]
lb := 2 + 1*b.n[0]
do_plot_nurbs_basis(b, la, lb)
plt.SaveD("/tmp/gosl", "t_nurbs03.eps")
}
}
func Test_Mw02(tst *testing.T) {
//verbose()
chk.PrintTitle("Mw02")
prms := []string{"φ", "Mfix"}
vals := []float64{32, 0}
var o NcteM
o.Init(prms, vals)
if SAVE_FIG {
// rosette
full, ref := false, true
r := 1.1 * SQ2 * o.M(1) / 3.0
PlotRosette(r, full, ref, true, 7)
// NcteM
npts := 201
X := make([]float64, npts)
Y := make([]float64, npts)
W := utl.LinSpace(-1, 1, npts)
for i, w := range W {
θ := math.Asin(w) / 3.0
r := SQ2 * o.M(w) / 3.0
X[i] = -r * math.Sin(math.Pi/6.0-θ)
Y[i] = r * math.Cos(math.Pi/6.0-θ)
//plt.Text(X[i], Y[i], io.Sf("$\\\\theta=%.2f$", θ*180.0/math.Pi), "size=8, ha='center', color='red'")
//plt.Text(X[i], Y[i], io.Sf("$w=%.2f$", w), "size=8, ha='center', color='red'")
}
plt.Plot(X, Y, "'b-'")
// MC
g := func(θ float64) float64 {
return SQ2 * o.Sinφ / (SQ3*math.Cos(θ) - o.Sinφ*math.Sin(θ))
}
io.Pforan("M( 1) = %v\n", SQ2*o.M(1)/3.0)
io.Pforan("g(30) = %v\n", g(math.Pi/6.0))
for i, w := range W {
θ := math.Asin(w) / 3.0
r := g(θ)
X[i] = -r * math.Sin(math.Pi/6.0-θ)
Y[i] = r * math.Cos(math.Pi/6.0-θ)
}
plt.Plot(X, Y, "'k-'")
// save
plt.Equal()
plt.SaveD("/tmp/gosl", "mw02.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 Test_nurbs04(tst *testing.T) {
//verbose()
chk.PrintTitle("nurbs04")
b := get_nurbs_B()
do_check_derivs(tst, b, 11, 1e-5, false)
if T_NURBS_SAVE {
la := 0 + 0*b.n[0]
lb := 2 + 1*b.n[0]
do_plot_nurbs_derivs(b, la, lb)
plt.SaveD("/tmp/gosl", "t_nurbs04.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)
}
// Save saves figure
func (o *Plotter) Save(typ, num string) {
if o.PlotFcn != nil {
o.PlotFcn()
}
ext := ".png"
if o.UseEps {
ext = ".eps"
}
if o.SaveFnk != "" {
if o.SaveDir != "" {
plt.SaveD(o.SaveDir, o.SaveFnk+typ+num+ext)
return
}
plt.Save(o.SaveFnk + typ + num + ext)
}
}
