Exemple #1
0
func TestWriteMath(t *testing.T) {
	want := `package gepModel

import (
	"math"
)

func gepModel(d []float64) float64 {
	y := 0.0

	y = (d[0] * d[0])
	y += d[0]
	y += (d[0] * (d[0] * d[0]))
	y += (((d[0] * d[0]) * d[0]) * d[0])

	return y
}
`

	g1 := gene.New("*.d0.d0.*.d0.*.*.d0.d0.d0.d0.d0.d0.d0.d0.d0.d0")
	g2 := gene.New("d0.*.d0.*.*.d0.d0.*.d0.d0.d0.d0.d0.d0.d0.d0.d0")
	g3 := gene.New("*.d0.*.d0.d0.*.d0.*.d0.d0.d0.d0.d0.d0.d0.d0.d0")
	g4 := gene.New("*.*.d0.*.d0.d0.d0.d0.d0.d0.d0.d0.d0.d0.d0.d0.d0")
	gn := New([]*gene.Gene{g1, g2, g3, g4}, "+")
	grammar, err := grammars.LoadGoMathGrammar()
	if err != nil {
		t.Fatalf("unable to LoadGoMathGrammar(): %v", err)
	}

	b := new(bytes.Buffer)
	gn.Write(b, grammar)
	if b.String() != want {
		t.Errorf("gen.Write() got %v, want %v", b.String(), want)
	}
}
Exemple #2
0
func main() {
	funcs := []gene.FuncWeight{
		{"+", 1},
		{"-", 1},
		{"*", 1},
	}
	numIn := len(srTests[0].in)
	e := model.New(funcs, mn.Math, 30, 8, 4, numIn, 0, "+", validateFunc)
	s := e.Evolve(10000)

	// Write out the Go source code for the solution.
	gr, err := grammars.LoadGoMathGrammar()
	if err != nil {
		log.Printf("unable to load Boolean grammar: %v", err)
	}
	fmt.Printf("\n// gepModel is auto-generated Go source code for the\n")
	fmt.Printf("// (a^4 + a^3 + a^2 + a) solution karva expression:\n// %q, score=%v\n", s, validateFunc(s))
	s.Write(os.Stdout, gr)
}
Exemple #3
0
func main() {
	grammar, err := grammars.LoadGoMathGrammar()
	// grammar, err := grammars.LoadGoBooleanAllGatesGrammar()
	// grammar, err := grammars.LoadGoBooleanNotAndOrGatesGrammar()
	// grammar, err := grammars.LoadGoBooleanNandGatesGrammar()
	// grammar, err := grammars.LoadGoBooleanNorGatesGrammar()
	// grammar, err := grammars.LoadGoBooleanMuxSystemGrammar()
	// grammar, err := grammars.LoadGoReedMullerSystemGrammar()
	if err != nil {
		log.Fatalf("unable to load math grammar: %v", err)
	}

	// fmt.Printf("grammar:\n%#v\n", grammar)

	v, err := xml.MarshalIndent(grammar, "", "   ")
	if err != nil {
		log.Printf("unable to marshal math grammar: %v", err)
	}

	fmt.Println(string(v))
}
Exemple #4
0
func TestConstants(t *testing.T) {
	want := "(d[0]+0.500000)"
	g := New("+.d0.c1.+.+.+.+.d0.d1.d1.d1.d0.d1.d1.d0")
	g.Constants = []float64{0.1, 0.5}
	grammar, err := grammars.LoadGoMathGrammar()
	if err != nil {
		t.Fatalf("unable to LoadGoBooleanAllGatesGrammar(): %v", err)
	}

	helpers := make(grammars.HelperMap)
	got, err := g.Expression(grammar, helpers)
	if err != nil {
		t.Fatalf("g.Expression error: %v", err)
	}
	if got != want {
		t.Errorf("g.Expression got %q, want %q", got, want)
	}
	if len(helpers) != 0 {
		t.Errorf("helpers got length %v, want 0", len(helpers))
	}
}