// CheckFront0 returns front0 and number of failed/success
func CheckFront0(opt *Optimiser, verbose bool) (nfailed int, front0 []*Solution) {
front0 = make([]*Solution, 0)
var nsuccess int
for _, sol := range opt.Solutions {
var failed bool
for _, oor := range sol.Oor {
if oor > 0 {
failed = true
break
}
}
if failed {
nfailed++
} else {
nsuccess++
if sol.FrontId == 0 {
front0 = append(front0, sol)
}
}
}
if verbose {
if nfailed > 0 {
io.PfRed("N failed = %d out of %d\n", nfailed, opt.Nsol)
} else {
io.PfGreen("N success = %d out of %d\n", nsuccess, opt.Nsol)
}
io.PfYel("N front 0 = %d\n", len(front0))
}
return
}
func Test_shp01(tst *testing.T) {
//verbose()
chk.PrintTitle("shp01")
r := []float64{0, 0, 0}
verb := true
for name, _ := range Functions {
io.Pfyel("--------------------------------- %-6s---------------------------------\n", name)
// check S
tol := 1e-17
if name == "tri10" {
tol = 1e-14
}
checkShape(tst, name, tol, verb)
// check dSdR
tol = 1e-14
if name == "lin5" || name == "lin4" || name == "tri10" || name == "qua12" || name == "qua16" {
tol = 1e-10
}
if name == "tri15" {
tol = 1e-9
}
checkDerivs(tst, name, r, tol, verb)
io.PfGreen("OK\n")
}
}
func Test_imap(tst *testing.T) {
//utl.Tsilent = false
chk.PrintTitle("Test imap")
for name, shape := range factory {
gndim := shape.Gndim
if gndim == 1 {
continue
}
io.Pfyel("--------------------------------- %-6s---------------------------------\n", name)
// check inverse mapping
tol := 1e-14
noise := 0.01
if name == "tri10" {
tol = 1e-14
}
if shape.FaceNvertsMax > 2 {
noise = 0.0
}
nverts := shape.Nverts
C := la.MatAlloc(gndim, nverts)
s := []float64{rand.Float64(), rand.Float64(), rand.Float64()} // scale factors
la.MatCopy(C, 1.0, shape.NatCoords)
_ = tol
io.Pf("nverts:%v\n", nverts)
io.Pf("gndim:%v\n", gndim)
for i := 0; i < gndim; i++ {
for j := 0; j < nverts; j++ {
C[i][j] *= s[i]
C[i][j] += noise * rand.Float64() // noise
}
}
r := make([]float64, 3)
x := make([]float64, 3)
R := la.MatAlloc(gndim, nverts)
for j := 0; j < nverts; j++ {
for i := 0; i < gndim; i++ {
x[i] = C[i][j]
}
err := shape.InvMap(r, x, C)
io.Pf("r:%v\n", r)
_ = err
for i := 0; i < gndim; i++ {
R[i][j] = r[i]
}
}
chk.Matrix(tst, "checking", tol, R, shape.NatCoords)
io.PfGreen("OK\n")
}
}
func main() {
mpi.Start(false)
defer func() {
mpi.Stop(false)
}()
if mpi.Rank() == 0 {
io.PfYel("\nTest MPI 04\n")
}
for i := 0; i < 60; i++ {
time.Sleep(1e9)
io.Pf("hello from %v\n", mpi.Rank())
if mpi.Rank() == 2 && i == 3 {
io.PfGreen("rank = 3 wants to abort (the following error is OK)\n")
mpi.Abort()
}
}
}
func Test_shape01(tst *testing.T) {
//verbose()
chk.PrintTitle("shape01")
r := []float64{0, 0, 0}
verb := true
for name, shape := range factory {
io.Pfyel("--------------------------------- %-6s---------------------------------\n", name)
// check S
tol := 1e-17
if name == "tri10" {
tol = 1e-14
}
CheckShape(tst, shape, tol, verb)
// check Sf
tol = 1e-18
CheckShapeFace(tst, shape, tol, verb)
// check dSdR
tol = 1e-14
if name == "lin5" || name == "lin4" || name == "tri10" || name == "qua12" || name == "qua16" {
tol = 1e-10
}
if name == "tri15" {
tol = 1e-9
}
CheckDSdR(tst, shape, r, tol, verb)
io.PfGreen("OK\n")
}
}
// 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
}
func Test_shape01(tst *testing.T) {
//utl.Tsilent = false
chk.PrintTitle("Test shape01")
for name, shape := range factory {
io.Pfyel("--------------------------------- %-6s---------------------------------\n", name)
// check S
tol := 1e-17
errS := 0.0
if name == "tri10" {
tol = 1e-14
}
for n := 0; n < shape.Nverts; n++ {
rst := []float64{0, 0, 0}
for i := 0; i < shape.Gndim; i++ {
rst[i] = shape.NatCoords[i][n]
}
shape.Func(shape.S, shape.dSdR, rst[0], rst[1], rst[2], false)
io.Pforan("S = %v\n", shape.S)
for m := 0; m < shape.Nverts; m++ {
if n == m {
errS += math.Abs(shape.S[m] - 1.0)
} else {
errS += math.Abs(shape.S[m])
}
}
}
if errS > tol {
tst.Errorf("%s failed with err = %g\n", name, errS)
return
}
// check dSdR
tol = 1e-14
h := 1.0e-1
S_temp := make([]float64, shape.Nverts)
if name == "lin5" || name == "tri15" || name == "lin4" || name == "tri10" || name == "qua12" || name == "qua16" {
tol = 1.0e-10
}
for n := 0; n < shape.Nverts; n++ {
rst := []float64{0, 0, 0}
for i := 0; i < shape.Gndim; i++ {
rst[i] = shape.NatCoords[i][n]
}
// analytical
shape.Func(shape.S, shape.dSdR, rst[0], rst[1], rst[2], true)
// numerical
for i := 0; i < shape.Gndim; i++ {
dSndRi, _ := num.DerivCentral(func(x float64, args ...interface{}) (Sn float64) {
rst_temp := []float64{rst[0], rst[1], rst[2]}
rst_temp[i] = x
shape.Func(S_temp, nil, rst_temp[0], rst_temp[1], rst_temp[2], false)
Sn = S_temp[n]
return
}, rst[i], h)
io.Pfgrey2(" dS%ddR%d @ [% 4.1f % 4.1f % 4.1f] = %v (num: %v)\n", n, i, rst[0], rst[1], rst[2], shape.dSdR[n][i], dSndRi)
tol2 := tol
if name == "tri15" && n == 11 && i == 1 {
tol2 = 1.0e-9
}
if math.Abs(shape.dSdR[n][i]-dSndRi) > tol2 {
tst.Errorf("%s dS%ddR%d failed with err = %g\n", name, n, i, math.Abs(shape.dSdR[n][i]-dSndRi))
return
}
//chk.Scalar(tst, fmt.Sprintf("dS%ddR%d", n, i), tol2, dSdR[n][i], dSndRi)
}
}
// check face vertices
tol = 1e-17
errS = 0.0
if name == "tri10" {
tol = 1e-14
}
nfaces := len(shape.FaceLocalV)
if nfaces == 0 {
continue
}
for k := 0; k < nfaces; k++ {
for n := range shape.FaceLocalV[k] {
rst := []float64{0, 0, 0}
for i := 0; i < shape.Gndim; i++ {
rst[i] = shape.NatCoords[i][n]
}
shape.Func(shape.S, shape.dSdR, rst[0], rst[1], rst[2], false)
io.Pforan("S = %v\n", shape.S)
for m := range shape.FaceLocalV[k] {
if n == m {
errS += math.Abs(shape.S[m] - 1.0)
} else {
errS += math.Abs(shape.S[m])
}
}
}
}
io.Pforan("%g\n", errS)
if errS > tol {
tst.Errorf("%s failed with err = %g\n", name, errS)
return
}
io.PfGreen("OK\n")
}
}
func Test_int01(tst *testing.T) {
//verbose()
chk.PrintTitle("int01. organise sequence of ints")
io.Pf("\n")
// initialise random numbers generator
rnd.Init(0) // 0 => use current time as seed
// parameters
C := NewConfParams()
C.Nova = 1
C.Noor = 0
C.Nisl = 1
C.Ninds = 20
C.RegTol = 0
C.NumInts = 20
//C.GAtype = "crowd"
C.CrowdSize = 2
C.Tf = 50
C.Verbose = chk.Verbose
C.CalcDerived()
// mutation function
C.Ops.MtInt = func(A []int, time int, ops *OpsData) {
size := len(A)
if !rnd.FlipCoin(ops.Pm) || size < 1 {
return
}
pos := rnd.IntGetUniqueN(0, size, ops.Nchanges)
for _, i := range pos {
if A[i] == 1 {
A[i] = 0
}
if A[i] == 0 {
A[i] = 1
}
}
}
// generation function
C.PopIntGen = func(id int, cc *ConfParams) Population {
o := make([]*Individual, cc.Ninds)
genes := make([]int, cc.NumInts)
for i := 0; i < cc.Ninds; i++ {
for j := 0; j < cc.NumInts; j++ {
genes[j] = rand.Intn(2)
}
o[i] = NewIndividual(cc.Nova, cc.Noor, cc.Nbases, genes)
}
return o
}
// objective function
C.OvaOor = func(ind *Individual, idIsland, time int, report *bytes.Buffer) {
score := 0.0
count := 0
for _, val := range ind.Ints {
if val == 0 && count%2 == 0 {
score += 1.0
}
if val == 1 && count%2 != 0 {
score += 1.0
}
count++
}
ind.Ovas[0] = 1.0 / (1.0 + score)
return
}
// run optimisation
evo := NewEvolver(C)
evo.Run()
// results
ideal := 1.0 / (1.0 + float64(C.NumInts))
io.PfGreen("\nBest = %v\nBestOV = %v (ideal=%v)\n", evo.Best.Ints, evo.Best.Ovas[0], ideal)
}