neat

type ActivationType byte

type Archiver interface {
	// Archives the current configuration and state to a more permanent medium
	Archive(Context) error
}

type Behaviorable interface {
	// Returns the expressed behaviors
	Behavior() []float64
}

type Comparer interface {
	// Returns the compatibility (similarity) between two genomes
	Compare(g1, g2 Genome) (float64, error)
}

type Connection struct {
	Innovation     int     // Innovation number for this connection
	Source, Target int     // Innovation numbers of the source and target nodes
	Weight         float64 // Connection weight
	Enabled        bool    // Is this connection enabled?
}

type Connections map[int]Connection

type Context interface {
	// Component helpers
	Archiver() Archiver
	Comparer() Comparer
	Crosser() Crosser
	Decoder() Decoder
	Evaluator() Evaluator
	Generator() Generator
	Mutator() Mutator
	Searcher() Searcher
	Speciater() Speciater
	Visualizer() Visualizer

	// State is a registry of elements to be persisted
	State() map[string]interface{}

	// Returns the next ID in the sequence
	NextID() int

	// Returns the innovation number for the gene
	Innovation(t InnoType, k InnoKey) int
}

type Contextable interface {
	SetContext(Context) error
}

type Crosser interface {
	// Returns new genome that is a cross between two genomes
	Cross(g1, g2 Genome) (Genome, error)
}

type Crossoverable interface {
	SetCrossover(bool) error
}

type Decoder interface {
	// Returns a decoded version of the genome
	Decode(Genome) (Phenome, error)
}

type Demonstrable interface {
	// ShowWork toggles the flag informing the helper to show (or) not the details during execution
	ShowWork(bool)
}

type Evaluator interface {
	// Evaluates a phenome for the problem. Returns the result.
	Evaluate(Phenome) Result
}

type Experiment struct {
	ExperimentSettings
	// contains filtered or unexported fields
}

type ExperimentSettings interface {
	Iterations() int
	Traits() Traits
	FitnessType() FitnessType
	ExperimentName() string
}

type FitnessType byte

type Generator interface {
	// Generates a subsequent population based on the current one
	Generate(curr Population) (next Population, err error)
}

type Genome struct {
	ID          int         // Identifier for this genome
	SpeciesIdx  int         // Index of species in the population
	Nodes       Nodes       // Neuron definitions
	Conns       Connections // Synapse definitions
	Traits      []float64   // Trait values
	Fitness     float64     // Fitness of genome as it relates to the problem itself
	Improvement float64     // Fitness of genome as it relates to the improvement of the population
	Birth       int         // Generation during which this genome was born
}

type Genomes []Genome

type Improvable interface {
	Improvement() float64
}

type InnoKey [2]float64

type InnoType byte

type Mutator interface {
	// Mutates a genome
	Mutate(*Genome) error
}

type Network interface {

	// Activates the neural network using the inputs. Returns the ouput values.
	Activate(inputs []float64) (outputs []float64, err error)
}

type NeuronType byte

type Node struct {
	Innovation int
	X, Y       float64
	NeuronType
	ActivationType
}

type Nodes map[int]Node

type OriginalFitnessable interface {
	OriginalFitness() float64
}

type Phenomable interface {
	// Provides the phenomes to the helper
	SetPhenomes(Phenomes) error
}

type Phenome interface {
	ID() int           // The identify of the underlying genome
	Traits() []float64 // Trait values which could be used during evaluation
	Network            // The decoded genome
}

type Phenomes []Phenome

type Populatable interface {
	// Provides the population to the helper
	SetPopulation(Population) error
}

type Population struct {
	Generation int
	Species    []Species
	Genomes    Genomes
}

type Restorer interface {
	// Restores the configuration and/or the state of a previous experiment
	Restore(Context) error
}

type Result interface {
	ID() int          // Returns the ID of the phenome
	Fitness() float64 // Returns the fitness of the phenome for the problem
	Err() error       // Returns the error, if any, occuring while evaluating the phenome.
	Stop() bool       // Returns true if the stop condition was met
}

type Results []Result

type Searcher interface {
	// Searches the problem's solution space using the phenomes
	Search([]Phenome) ([]Result, error)
}

type Setupable interface {
	// Sets up the helper
	Setup() error
}

type Speciater interface {
	// Assigns the genomes to a species. Returns new collection of species.
	Speciate(curr []Species, genomes []Genome) (next []Species, err error)
}

type Species struct {
	Age         int // Age in terms of generations
	Stagnation  int // Number of generations since an improvement
	Improvement float64
	Example     Genome
}

type Takedownable interface {
	// Takes down the helper
	Takedown() error
}

type Trait struct {
	Name      string
	Min, Max  float64
	IsSetting bool
}

type Traits []Trait

type Trialable interface {
	SetTrial(int) error
}

type Visualizer interface {
	// Creates visual(s) of the population
	Visualize(Population) error
}