diff --git a/main.go b/main.go new file mode 100644 index 0000000000000000000000000000000000000000..680f73e7849f3dfb6f065b5b37b2938c25cf8031 --- /dev/null +++ b/main.go @@ -0,0 +1,155 @@ +// Aug 2021 + +// Ackley_mc is for playing with Monte Carlo or simulated annealing on the +// ackley function in N dimensions. +// +// ackley_mc [-n nthread] [-v] ini fnl seed n_step x_ini +// so, +// go run . 200 100 1637 300 1,2,3 +// will start at 200, cool down to 100 over 300 steps and use 1637 as the +// randome number seed. It will be a 3 dimensional function starting from the +// coordinates 1,2,3 + +package main + +import ( + "os" + "fmt" + "flag" + "strconv" + "strings" + + "ackley_mc/ackley" +) + +const ndimDflt = 2 +const ( + exitSuccess = iota + exitFailure +) + +type mcPrm struct { + iniTmp, fnlTmp float32 + xIni []float32 + nStep uint32 + nRun uint32 + verbose bool +} + +var seed int64 + +// usage +func usage() { + u := ` +[options] seed initial_temp final_temp num_steps initial_x +and the initial_x is a comma separated list of values like "7,7,7"` + fmt.Fprintln(flag.CommandLine.Output(), "usage of %s", os.Args[0], u) + flag.PrintDefaults() +} + +// cmdln sorts out the command line +func cmdLn() (mcPrm, error) { + var mcPrm mcPrm = mcPrm {nRun: 1, verbose: true} + + var utmp uint + flag.UintVar(&utmp, "r", 1, "number of runs") + flag.BoolVar(&mcPrm.verbose, "v", true, "verbose") + flag.Usage = usage + flag.Parse() + mcPrm.nRun = uint32 (utmp) + var err error + tooFewArgs := fmt.Errorf ("Too few command line arguments") + getf := func (s string) float32 { + if err != nil { + return 0.0 } + if s == "" { + err = tooFewArgs + } + r := 0. + r, err = strconv.ParseFloat(s, 32) + return float32(r) + } + getu := func (s string) uint32 { + if err != nil { + return 0} + if s == "" { + err = tooFewArgs + return 0 + } + var u uint64 + u, err = strconv.ParseUint(s, 10, 32) + return uint32(u) + } + + getx := func (s string) []float32 { + if err != nil { + return nil + } + if s == "" { + err = tooFewArgs + return nil + } + y := strings.Split(s, ",") + if len(y) < 1 { + err = fmt.Errorf("broke trying to get initial x values") + return nil + } + x := make ([]float32, len(y)) + for i, s := range y { + r := 0. + if r, err = strconv.ParseFloat(s, 32); err != nil { + return nil + } + x[i] = float32(r) + } + return x + } + if flag.NArg() != 4 && false{ + flag.Usage() + return mcPrm, fmt.Errorf("Wrong number of command line args") + } + mcPrm.iniTmp = getf(flag.Arg(0)) + mcPrm.fnlTmp = getf(flag.Arg(1)) + seed = int64 (getu(flag.Arg(2))) + mcPrm.nStep = getu(flag.Arg(3)) + mcPrm.xIni = getx (flag.Arg(4)) + if err != nil { + return mcPrm, err + } + + if mcPrm.verbose { + fmt.Println ("initial temp:", mcPrm.iniTmp, + "\nfinal temp:", mcPrm.fnlTmp, + "\nseed:", seed, + "\nn steps:", mcPrm.nStep, + "\nn runs:", mcPrm.nRun, + "\ninitial x:", mcPrm.xIni) + + } + return mcPrm, nil +} + + + +// myMain +func myMain () error { + var mcPrm mcPrm + var err error + if mcPrm, err = cmdLn(); err != nil { + return err + } + + x := [1]float32{0.001} + fmt.Println("ackley ", ackley.Ackley(x[:])) + fmt.Println("mcPrm", mcPrm) + doRun (mcPrm) + doRun (mcPrm) + return nil +} +func main() { + if err := myMain (); err != nil { + fmt.Println (os.Stderr, err) + os.Exit (exitFailure) + } + os.Exit (exitSuccess) +}