eevee3

type ConsistentSizeSliceSolution[E comparable] struct {
	Slice []E
}

type Controller[T any] struct {
	Recorder Recorder[T]

	// GenerationCycles is the number of generation cycles
	// to run the experiment for
	GenerationCycles int

	// PopulationSize represents the number of solutions
	// in each generation corpus
	PopulationSize int

	// MutationProbability is the probability that
	// each solutions has to mutate on each generation cycle
	MutationProbability float64

	// CrossoverProbability is the probability that
	// each pair of solutions has to crossover together
	CrossoverProbability float64

	// CrossoverSelectionStrategy is the strategy used to select pairs
	// for crossover
	CrossoverSelectionStrategy PairwiseSelectionStrategy[T]

	// NextGenerationSelectionStrategy is the strategy used in each iteration
	// to select the next corpus of solutions
	NextGenerationSelectionStrategy SubgroupSelectionStrategy[T]

	// TerminationConditions allows for input of conditions
	// that may allow for early termination of the experiment
	TerminationConditions []PopulationPredicate[T]
}

type Crossover[TUnderlying any] interface {
	// Cross takes 2 solutions instances and performs a crossover on them
	Cross(solution1, solution2 Solution[TUnderlying]) (Solution[TUnderlying], Solution[TUnderlying])
}

type Handler[TUnderlying any] interface {
	Crossover[TUnderlying]
	Mutation[TUnderlying]

	// NewSolution returns a single solutions instance
	NewSolution() Solution[TUnderlying]
	NewSolutionFrom(innerValue TUnderlying) Solution[TUnderlying]
}

type IOWriterRecorder[T any] struct {
	// contains filtered or unexported fields
}

type Mutation[TUnderlying any] interface {
	// Mutate takes a single solutions instance and performs a mutation on it
	Mutate(solution Solution[TUnderlying]) Solution[TUnderlying]
}

type PairwiseSelectionStrategy[T any] func(corpus []Solution[T]) [][2]Solution[T]

type PopulationPredicate[T any] func([]Solution[T]) (PredicateReason, bool)

type PredicateReason string

type Recorder[T any] interface {
	// ExperimentStart marks the start of the experiment
	ExperimentStart(controller Controller[T])

	// InitialPopulation records the initial population
	InitialPopulation(population []Solution[T])

	// Generation records whenever a new generation cycle begins
	Generation(generation int)

	// Crossover records each crossover event
	Crossover(in1, in2, out1, out2 Solution[T])

	// Mutate records each mutation event
	Mutate(in, out Solution[T])

	// Selection records the selection process at the end of each cycle
	Selection(before, after []Solution[T])

	// Terminate records a termination
	Terminate(result Result[T])
}

type RecorderConfig struct {
	ExperimentStart   bool
	InitialPopulation bool
	Generation        bool
	Crossover         bool
	Mutate            bool
	Selection         bool
	Terminate         bool
}

type Result[T any] struct {
	Population             []Solution[T] `json:"population"`
	TerminatedAtGeneration int           `json:"terminatedAtGeneration"`
	TerminationReason      string        `json:"terminationReason"`
}

type Solution[TUnderlying any] interface {
	fmt.Stringer

	// Score returns the solutions's individual score
	Score() float64

	// Value returns the underlying value backing the solutions
	Value() TUnderlying

	// Equals returns true if the solutions is
	// identical to the given other solutions
	Equals(Solution[TUnderlying]) bool

	// Clone returns a clone that has no shared memory references
	// with the original
	Clone() Solution[TUnderlying]

	// Describe returns textual information describing the solutions.
	// This may be information to be presented at the end of a run, etc.
	Describe() string
}

type SolutionPredicate[T any] func(solution Solution[T]) (PredicateReason, bool)

type SubgroupSelectionStrategy[T any] func(corpus []Solution[T]) []Solution[T]