unit 0.26.2

A self-replicating software nanobot — minimal Forth interpreter that is also a networked mesh agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

package evolve

import (
	"math/rand"
	"testing"
)

func TestEvalNum(t *testing.T) {
	n := &Num{Val: 42}
	if n.Eval() != 42 {
		t.Fatalf("expected 42, got %d", n.Eval())
	}
}

func TestEvalBinOp(t *testing.T) {
	expr := &BinOp{Op: "+", Left: &Num{Val: 10}, Right: &Num{Val: 32}}
	if expr.Eval() != 42 {
		t.Fatalf("expected 42, got %d", expr.Eval())
	}
}

func TestEvalNested(t *testing.T) {
	// (+ (* 5 11) 0) = 55
	expr := &BinOp{
		Op:    "+",
		Left:  &BinOp{Op: "*", Left: &Num{Val: 5}, Right: &Num{Val: 11}},
		Right: &Num{Val: 0},
	}
	if expr.Eval() != 55 {
		t.Fatalf("expected 55, got %d", expr.Eval())
	}
}

func TestEvalDivByZero(t *testing.T) {
	expr := &BinOp{Op: "mod", Left: &Num{Val: 10}, Right: &Num{Val: 0}}
	if expr.Eval() != 0 {
		t.Fatalf("expected 0 for div-by-zero, got %d", expr.Eval())
	}
}

func TestMutateProducesValid(t *testing.T) {
	rng := rand.New(rand.NewSource(42))
	expr := &BinOp{Op: "+", Left: &Num{Val: 5}, Right: &Num{Val: 10}}
	for i := 0; i < 20; i++ {
		mutated := Mutate(rng, expr)
		mutated.Eval() // should not panic
	}
}

func TestCrossoverProducesValid(t *testing.T) {
	rng := rand.New(rand.NewSource(99))
	a := &BinOp{Op: "+", Left: &Num{Val: 5}, Right: &Num{Val: 10}}
	b := &BinOp{Op: "*", Left: &Num{Val: 3}, Right: &Num{Val: 7}}
	for i := 0; i < 20; i++ {
		child := Crossover(rng, a, b)
		child.Eval() // should not panic
	}
}

func TestRunEvolutionFinds55(t *testing.T) {
	expr, found := RunEvolution(55, 500, 42)
	if !found {
		t.Logf("evolution did not find exact 55, best: %s = %d", expr.String(), expr.Eval())
		// Not a hard failure — GP is stochastic.
		return
	}
	if expr.Eval() != 55 {
		t.Fatalf("claimed found but eval is %d", expr.Eval())
	}
}

func TestRunEvolutionFinds42(t *testing.T) {
	expr, found := RunEvolution(42, 500, 123)
	if !found {
		t.Logf("evolution did not find exact 42, best: %s = %d", expr.String(), expr.Eval())
		return
	}
	if expr.Eval() != 42 {
		t.Fatalf("claimed found but eval is %d", expr.Eval())
	}
}

func TestScoreExact(t *testing.T) {
	expr := &Num{Val: 55}
	s := Score(expr, 55)
	if s < 900 {
		t.Fatalf("expected high score for exact match, got %f", s)
	}
}

func TestScoreWrong(t *testing.T) {
	expr := &Num{Val: 100}
	s := Score(expr, 55)
	if s >= 900 {
		t.Fatalf("expected low score for wrong answer, got %f", s)
	}
}

func TestParseTarget(t *testing.T) {
	n, ok := ParseTarget("55 ")
	if !ok || n != 55 {
		t.Fatalf("expected 55, got %d ok=%v", n, ok)
	}
}

func TestFormatProgram(t *testing.T) {
	expr := &BinOp{Op: "+", Left: &Num{Val: 5}, Right: &Num{Val: 50}}
	s := FormatProgram(expr)
	if s != "(+ 5 50)" {
		t.Fatalf("expected (+ 5 50), got %s", s)
	}
}