Score on criteria count, not sample count

grow/definition.go

@@ -30,22 +30,24 @@ func NewDefinition(r io.Reader) (*Definition, error) {
 
 func (def *Definition) Grow(statusChan chan<- Status) (*vm.Program, error) {
 	status := Status{
-		TargetScore: uint64(len(def.Samples)),
+		TargetScore: def.sumOuts(),
 	}
 
 	if statusChan != nil {
 		statusChan <- status
 	}
 
-	// TODO: Score should be number of output criteria, not number of Samples
 	for {
 		status.Attempts++
 
 		prog := gen.RandProgram(def.GlobalMemorySize, def.FunctionMemorySize, def.InstructionLimit)
 
-		score, err := def.Score(prog)
+		score, err := def.score(prog)
 		if err != nil {
-			close(statusChan)
+			if statusChan != nil {
+				close(statusChan)
+			}
+
 			return nil, err
 		}
 
@@ -58,14 +60,17 @@ func (def *Definition) Grow(statusChan chan<- Status) (*vm.Program, error) {
 			}
 
 			if status.BestScore == status.TargetScore {
-				close(statusChan)
+				if statusChan != nil {
+					close(statusChan)
+				}
+
 				return prog, nil
 			}
 		}
 	}
 }
 
-func (def *Definition) Score(prog *vm.Program) (uint64, error) {
+func (def *Definition) score(prog *vm.Program) (uint64, error) {
 	score := uint64(0)
 
 	for _, sample := range def.Samples {
@@ -78,10 +83,18 @@ func (def *Definition) Score(prog *vm.Program) (uint64, error) {
 
 		state.Execute() // ignore error
 
-		if sample.OutputsMatch(state) {
-			score += 1
-		}
+		score += sample.matchingOuts(state)
 	}
 
 	return score, nil
 }
+
+func (def *Definition) sumOuts() uint64 {
+	sum := uint64(0)
+
+	for _, sample := range def.Samples {
+		sum += uint64(len(sample.Out))
+	}
+
+	return sum
+}

grow/sample.go

@@ -13,12 +13,14 @@ func (s *Sample) SetInputs(state *vm.State) {
 	}
 }
 
-func (s *Sample) OutputsMatch(state *vm.State) bool {
+func (s *Sample) matchingOuts(state *vm.State) uint64 {
+	ret := uint64(0)
+
 	for i, val := range s.Out {
-		if state.GlobalMemory().MustReadUnsigned(uint64(i)) != val {
-			return false
+		if state.GlobalMemory().MustReadUnsigned(uint64(i)) == val {
+			ret++
 		}
 	}
 
-	return true
+	return ret
 }

test/grow_test.go

@@ -12,22 +12,17 @@ global_memory_size: 1
 function_memory_size: 1
 instruction_limit: 2
 samples:
-- global_memory_inputs:
-    0: 0
-  global_memory_outputs:
-    0: 0
-- global_memory_inputs:
-    0: 1
-  global_memory_outputs:
-    0: 5
-- global_memory_inputs:
-    0: 2
-  global_memory_outputs:
-    0: 10
-- global_memory_inputs:
-    0: 100
-  global_memory_outputs:
-    0: 500
+- in:  [0]
+  out: [0]
+
+- in:  [1]
+  out: [5]
+
+- in:  [2]
+  out: [10]
+
+- in:  [100]
+  out: [500]
 `))
 
 	def, err := grow.NewDefinition(r)
@@ -35,7 +30,7 @@ samples:
 		t.Fatal(err)
 	}
 
-	prog, err := def.Grow()
+	prog, err := def.Grow(nil)
 	if err != nil {
 		t.Fatal(err)
 	}