Working well and the test9d with plots look very pretty.

ackwork/ackwork_test.go

@@ -108,17 +108,28 @@ func TestCsv(t *testing.T) {
 	}
 }
 
-var s1dplot = `
+var s9dplot = `
 ini_temp 0.0925
 final_temp 0.09
 x_ini 15,10,11,12,14,18,-12,-8,-9
-n_step 1000
+n_step 50000
+x_delta 0.2
 fOutName test9d
 fPltName testplot.svg
 xPltName testrajplt`
 
+var s9bdplot = `
+ini_temp 0.0925
+final_temp 0.09
+x_ini 15,10,11,12,14,0,-12,-8,-9
+n_step 50000
+x_delta 0.2
+fOutName test9db
+fPltName test9dbf
+xPltName test9dbtraj`
+
 var plotTest = []string{
-	s1dplot,
+	s9dplot, s9bdplot,
 }
 
 func TestPlot(t *testing.T) {

ackwork/dorun.go

@@ -146,18 +146,18 @@ func saveStep(cprm *cprm, n uint32, tmprtr float64, x []float32, fTrial float64)
 }
 
 // nRunAdj will try to adjust the step size, given our history of accept/reject.
-func nRunAdj(mcPrm *mcPrm, runAcc float64, xDlta float32) float32 {
+func nRunAdj(mcPrm *mcPrm, nstep uint32, runAcc float64, xDlta float32) float32 {
 	const step = "step"
 
 	if runAcc < accRateIdeal-0.01 { // acceptance rate too low
 		xDlta *= 0.9
 		if mcPrm.verbose {
-			fmt.Println(step, xDlta, "decrease")
+			fmt.Println(step, nstep, "decrease", xDlta)
 		}
 	} else if (xDlta < maxxDlta) && (runAcc > accRateIdeal+0.01) {
 		xDlta *= 1.1
 		if mcPrm.verbose {
-			fmt.Println(step, xDlta, "increase")
+			fmt.Println(step, nstep, "increase",  xDlta)
 		}
 	}
 	return xDlta
@@ -188,26 +188,25 @@ func doRun(mcPrm *mcPrm) error {
 	runAcc := accRateIdeal                 // Running acceptance rate, exponentially weighted
 	copy(x, mcPrm.xIni)
 	fOld := ackley.Ackley(x) // Initial function value
+	fTrial := fOld
 	tmprtr := float64(mcPrm.iniTmp)
 	nRunAcc := nRunAccAdj // Every nRunAccAdj, try adjusting the step size.
 	const runMult = 0.99
 	xDlta := mcPrm.xDlta // Adaptable step size
+	if mcPrm.fOutName == "test9d.csv"{
+		breaker()
+	}
 	saveStep(&cprm, 0, tmprtr, x, fOld)
 
 	for n := uint32(0); n < mcPrm.nStep; n++ {
 		var acc bool
-		// nout--
-		// if nout == 0 { // Do we want to print out results on this step ?
-		// 	printfVal(cprm.fOut, x, n, tmprtr, fOld)
-		// 	nout = cprm.nEvery
-		// }
 		nRunAcc--
 		if nRunAcc == 0 { // Do we want to try adjusting the step size ?
-			xDlta = nRunAdj(mcPrm, runAcc, xDlta)
+			xDlta = nRunAdj(mcPrm, n, runAcc, xDlta)
 			nRunAcc = nRunAccAdj // Reset the counter
 		}
 		newx(x, xT, cprm.rand, xDlta)
-		fTrial := ackley.Ackley(xT)
+		fTrial = ackley.Ackley(xT)
 
 		if fOld < fTrial {
 			r := cprm.rand.Float64() // Make the decision as to whether to
@@ -232,7 +231,14 @@ func doRun(mcPrm *mcPrm) error {
 			tmprtr *= cprm.coolMult
 		}
 	}
+	if mcPrm.fOutName == "test9d.csv"{
+		breaker()
+	}
+
 	// On plots, we want the last step, even if nothing changed. Print me. Fix.
+	if fTrial != fOld { // last move was not accepted, so we have to add last step
+		saveStep (&cprm, mcPrm.nStep, tmprtr, x, fOld)
+	}
 	err := plotfWrt(cprm.plotnstp, cprm.plotf, cprm.plotTmprtr, cprm.fPlt, cprm.fplotme)
 	if err != nil {
 		return err