nucleotide

package module

Go to main page

Versions in this module

v0

v0.13.0

Jul 24, 2026

Changes in this version

+ type AdaptiveWindowController interface

+ GetWindowSize func(generation int, diversity float64) int

+ type CallbackWindowController struct

+ Callback func(generation int, diversity float64) int

+ func NewCallbackWindowController[Env any, State any](cb func(generation int, diversity float64) int) *CallbackWindowController[Env, State]

+ func (c *CallbackWindowController[Env, State]) GetWindowSize(generation int, diversity float64) int

+ type DiversityFeedbackWindowController struct

+ MaxSize int

+ MinSize int

+ Sensitivity float64

+ TargetDiversity float64

+ func NewDiversityFeedbackWindowController[Env any, State any](min, max int, target float64, sensitivity float64) *DiversityFeedbackWindowController[Env, State]

+ func (c *DiversityFeedbackWindowController[Env, State]) GetWindowSize(generation int, diversity float64) int

type Engine

+ WindowSize int

type EngineConfig

+ AdaptiveWindow bool

+ MaxWindowSize int

+ MinWindowSize int

+ WindowController AdaptiveWindowController[Env, State]

+ type LinearDecayWindowController struct

+ EndSize int

+ MaxGenerations int

+ StartSize int

+ func NewLinearDecayWindowController[Env any, State any](start, end, maxGens int) *LinearDecayWindowController[Env, State]

+ func (c *LinearDecayWindowController[Env, State]) GetWindowSize(generation int, diversity float64) int

+ type WindowAwareEnvironment interface

+ SetWindowSize func(size int)

v0.12.0

Jul 23, 2026

Changes in this version

type Engine

+ func (e *Engine[Env, State]) EvaluateIndividual(ind *Individual[Env, State])

type EngineConfig

+ EnableFitnessCache bool

+ type FitnessCache struct

+ func NewFitnessCache() *FitnessCache

+ func (c *FitnessCache) GetOrCreateEntry(key string) (*sync.Mutex, *bool, *[]float64)

+ type PointerAdaptiveMutator struct

+ BaseMutator Mutator

+ ProbabilityPointer *float64

+ func NewPointerAdaptiveMutator(base Mutator, ptr *float64) PointerAdaptiveMutator

+ func (m PointerAdaptiveMutator) Mutate(g Genome) Genome

+ type SwapCategoricalMutator struct

+ Probability float64

+ func (m SwapCategoricalMutator) Mutate(g Genome) Genome

v0.11.0

Jul 23, 2026

Changes in this version

+ type AdaptivePopulationController interface

+ GetPopulationSize func(e *Engine[Env, State]) int

+ type CallbackPopulationController struct

+ Callback func(e *Engine[Env, State]) int

+ func NewCallbackPopulationController[Env any, State any](cb func(e *Engine[Env, State]) int) *CallbackPopulationController[Env, State]

+ func (c *CallbackPopulationController[Env, State]) GetPopulationSize(e *Engine[Env, State]) int

+ type DiversitySigmoidPopulationController struct

+ BaseSize int

+ MaxSize int

+ MinSize int

+ Sensitivity float64

+ TargetDiversity float64

+ func NewDiversitySigmoidPopulationController[Env any, State any](target float64, sensitivity float64, base, min, max int) *DiversitySigmoidPopulationController[Env, State]

+ func (c *DiversitySigmoidPopulationController[Env, State]) GetPopulationSize(e *Engine[Env, State]) int

+ type DiversityThresholdPopulationController struct

+ BaselineSize int

+ DecreaseFactor float64

+ HighThreshold float64

+ IncreaseFactor float64

+ LowThreshold float64

+ func NewDiversityThresholdPopulationController[Env any, State any](low, high, inc, dec float64, baseline int) *DiversityThresholdPopulationController[Env, State]

+ func (c *DiversityThresholdPopulationController[Env, State]) GetPopulationSize(e *Engine[Env, State]) int

type EngineConfig

+ AdaptivePopulation bool

+ MaxPopulationSize int

+ MinPopulationSize int

+ PopulationController AdaptivePopulationController[Env, State]

+ type PopulationScheduleType int

+ const PopulationScheduleCosine

+ const PopulationScheduleExponential

+ const PopulationScheduleLinear

+ type StagnationPopulationController struct

+ BaselineSize int

+ DecreaseFactor float64

+ IncreaseFactor float64

+ StagnationLimit int

+ func NewStagnationPopulationController[Env any, State any](limit int, inc, dec float64, baseline int) *StagnationPopulationController[Env, State]

+ func (c *StagnationPopulationController[Env, State]) GetPopulationSize(e *Engine[Env, State]) int

+ type TemporalSchedulePopulationController struct

+ CycleLength int

+ InitialSize int

+ TargetSize int

+ Type PopulationScheduleType

+ func NewTemporalSchedulePopulationController[Env any, State any](sType PopulationScheduleType, initSize, targetSize, cycle int) *TemporalSchedulePopulationController[Env, State]

+ func (c *TemporalSchedulePopulationController[Env, State]) GetPopulationSize(e *Engine[Env, State]) int

v0.10.0

Jun 19, 2026

Changes in this version

type EngineConfig

+ Silent bool

+ type GPConfig struct

+ Constants []float64

+ Functions []GPFunctionInfo

+ MaxDepth int

+ MinDepth int

+ Variables []string

+ type GPCrossover struct

+ MaxDepth int

+ func (c GPCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type GPFunction func(args []float64) float64

+ type GPFunctionInfo struct

+ Arity int

+ Eval GPFunction

+ Name string

+ func GetAdvancedFunctions() []GPFunctionInfo

+ func GetBasicArithmeticFunctions() []GPFunctionInfo

+ type GPGenome struct

+ Config *GPConfig

+ Root *GPNode

+ func NewRampedHalfAndHalfPopulation(config *GPConfig, size int) []*GPGenome

+ func (g *GPGenome) Copy() Genome

+ func (g *GPGenome) Evaluate(vars map[string]float64) float64

+ func (g *GPGenome) Size() int

+ func (g *GPGenome) String() string

+ type GPMutator struct

+ Config *GPConfig

+ MaxDepth int

+ Probability float64

+ SubtreeProb float64

+ func (m GPMutator) Mutate(g Genome) Genome

+ type GPNode struct

+ Children []*GPNode

+ Op string

+ func (n *GPNode) Copy() *GPNode

+ func (n *GPNode) Depth() int

+ func (n *GPNode) Evaluate(vars map[string]float64, config *GPConfig) float64

+ func (n *GPNode) Size() int

+ func (n *GPNode) String() string

v0.9.1

May 31, 2026

Changes in this version

+ func EncodeGenome(g Genome) ([]byte, error)

+ func SaveGenome(g Genome, filename string) error

+ type AdaptiveMutationController interface

+ GetMutationScaler func(e *Engine[Env, State]) float64

+ type ArithmeticCrossover struct

+ Alpha float64

+ func (c ArithmeticCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type BitFlipMutator struct

+ Probability float64

+ func (m BitFlipMutator) Mutate(g Genome) Genome

+ type BitGenome []bool

+ func (g BitGenome) Copy() Genome

+ func (g BitGenome) Size() int

+ type BoltzmannSelector struct

+ Temperature float64

+ func (s BoltzmannSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s BoltzmannSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ type CategoricalCreepMutator struct

+ Probability float64

+ func (m CategoricalCreepMutator) Mutate(g Genome) Genome

+ type CategoricalGenome struct

+ Definition *Definition[Env, State]

+ GeneIndices []int

+ func (g *CategoricalGenome[Env, State]) Copy() Genome

+ func (g *CategoricalGenome[Env, State]) GetDefinition() interface{}

+ func (g *CategoricalGenome[Env, State]) GetGenePairs() []LocusGenePair

+ func (g *CategoricalGenome[Env, State]) GetIndices() []int

+ func (g *CategoricalGenome[Env, State]) GetLocus(i int) (int, bool, bool)

+ func (g *CategoricalGenome[Env, State]) SetIndices(indices []int)

+ func (g *CategoricalGenome[Env, State]) Size() int

+ type CategoricalMutator struct

+ Probability float64

+ func (m CategoricalMutator) Mutate(g Genome) Genome

+ type CompositeGenome map[string]Genome

+ func (g CompositeGenome) Copy() Genome

+ func (g CompositeGenome) Size() int

+ type Context struct

+ Ctx context.Context

+ Env Env

+ Individual *Individual[Env, State]

+ type Crossoverer interface

+ Crossover func(p1, p2 Genome) (Genome, Genome)

+ type CycleCrossover struct

+ func (c CycleCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type DefaultCrossoverer struct

+ func (c DefaultCrossoverer) Crossover(p1, p2 Genome) (Genome, Genome)

+ type DefaultMutator struct

+ Probability float64

+ func (m DefaultMutator) Mutate(g Genome) Genome

+ type Definition struct

+ Loci []*Locus[Env, State]

+ func NewDefinition[Env any, State any]() *Definition[Env, State]

+ func (d *Definition[Env, State]) AddLocus(id string, lType LocusType) *Locus[Env, State]

+ func (d *Definition[Env, State]) AddSequenceGene(id string, min, max int)

+ type EdgeRecombinationCrossover struct

+ func (c EdgeRecombinationCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type ElitismFunc func(pop Population[Env, State], size int) Population[Env, State]

+ type Engine struct

+ Config EngineConfig[Env, State]

+ DiversityHistory []float64

+ Generation int

+ Population Population[Env, State]

+ SuccessfulMutations int

+ TotalMutations int

+ func NewEngine[Env any, State any](config EngineConfig[Env, State]) (*Engine[Env, State], error)

+ func (e *Engine[Env, State]) ParetoFrontier() Population[Env, State]

+ func (e *Engine[Env, State]) Run(def *Definition[Env, State]) (*Individual[Env, State], error)

+ func (e *Engine[Env, State]) Step(def *Definition[Env, State]) error

+ type EngineConfig struct

+ AdaptiveMutation bool

+ AgeBiasedMutation bool

+ AgeMutationScaler float64

+ AgeMutationThreshold int

+ ConcurrencyLimit int

+ Crossoverers []WeightedCrossoverer

+ DisableParallelFitness bool

+ DisableParallelReproduction bool

+ Elitism int

+ ElitismFunc ElitismFunc[Env, State]

+ Env Env

+ FitnessFunc FitnessFunc[Env, State]

+ MaxGenerations int

+ MaxMutationScaler float64

+ MutationController AdaptiveMutationController[Env, State]

+ Mutators []WeightedMutator

+ ObjectiveDirections []ObjectiveDirection

+ OnMutationAdapted func(generation int, diversity float64, currentScaler float64)

+ PopulationFunc PopulationFunc[Env, State]

+ PopulationSize int

+ Selector Selector

+ Strategy GenerationStrategy[Env, State]

+ Verbose bool

+ type ExponentialRankSelector struct

+ C float64

+ func (s ExponentialRankSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s ExponentialRankSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ type FitnessFunc func(g Genome, env Env) []float64

+ type FloatGenome []float64

+ func (g FloatGenome) Copy() Genome

+ func (g FloatGenome) Size() int

+ type GaussianMutator struct

+ Probability float64

+ StdDev float64

+ func (m GaussianMutator) Mutate(g Genome) Genome

+ type Gene struct

+ Callback func(ctx Context[Env, State])

+ ID string

+ Value interface{}

+ type GenerationEndHook interface

+ OnGenerationEnd func(generation int, pop Population[Env, State])

+ type GenerationStartHook interface

+ OnGenerationStart func(generation int, pop Population[Env, State])

+ type GenerationStrategy interface

+ Initialize func(e *Engine[Env, State]) error

+ NextGeneration func(e *Engine[Env, State], def *Definition[Env, State], ...) (Population[Env, State], error)

+ type GenericTournamentSelector struct

+ AdaptiveDiversity bool

+ AgeBias float64

+ DistanceFunc func(g1, g2 Genome) float64

+ GenerationProgress func() float64

+ HallOfFame *Population[Env, State]

+ HallOfFameProbability float64

+ MaxSize int

+ MinSize int

+ NichingAlpha float64

+ Probability float64

+ SelfAdaptive bool

+ SigmaShare float64

+ Size int

+ Unique bool

+ func NewAdaptiveTournamentSelector[Env any, State any](minSize, maxSize int, progressFunc func() float64) GenericTournamentSelector[Env, State]

+ func NewNichingTournamentSelector[Env any, State any](size int, sigma float64, distFunc func(g1, g2 Genome) float64) GenericTournamentSelector[Env, State]

+ func NewProbabilisticTournamentSelector[Env any, State any](size int, probability float64) GenericTournamentSelector[Env, State]

+ func NewUniqueTournamentSelector[Env any, State any](size int) GenericTournamentSelector[Env, State]

+ func (s GenericTournamentSelector[Env, State]) DetermineTournamentSize(pop Population[Env, State]) int

+ func (s GenericTournamentSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s GenericTournamentSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ func (s GenericTournamentSelector[Env, State]) SelfAdaptiveSelectionSizeOverride(pop Population[Env, State]) (Population[Env, State], int)

+ type Genome interface

+ Copy func() Genome

+ Size func() int

+ func DecodeGenome[Env any, State any](def *Definition[Env, State], data []byte) (Genome, error)

+ func LoadGenome[Env any, State any](def *Definition[Env, State], filename string) (Genome, error)

+ type GenomeData struct

+ Bits BitGenome

+ Floats FloatGenome

+ Genes []LocusGenePair

+ Sequence SequenceGenome

+ Sequences map[string]SequenceGenome

+ Type string

+ type Individual struct

+ Age int

+ CrowdingDistance float64

+ Fitness []float64

+ Genome Genome

+ MutationRate float64

+ ParentFitness []float64

+ Rank int

+ State State

+ func NewIndividual[Env any, State any](genome Genome) *Individual[Env, State]

+ func (ind *Individual[Env, State]) Express(ctx context.Context, env Env)

+ func (ind *Individual[Env, State]) GetParameter(locusID string) interface{}

+ func (ind *Individual[Env, State]) GetSequence(locusID string) SequenceGenome

+ func (ind *Individual[Env, State]) Save(filename string) error

+ func (ind *Individual[Env, State]) ToJSON() ([]byte, error)

+ type LinearRankSelector struct

+ SelectionPressure float64

+ func (s LinearRankSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s LinearRankSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ type Locus struct

+ ID string

+ Immutable bool

+ PossibleGenes []Gene[Env, State]

+ SeqMax int

+ SeqMin int

+ Type LocusType

+ func (l *Locus[Env, State]) AddConfigGene(id string, value interface{})

+ func (l *Locus[Env, State]) AddGene(id string, callback func(ctx Context[Env, State]))

+ func (l *Locus[Env, State]) AddParameterGene(id string, value interface{})

+ func (l *Locus[Env, State]) AddSequenceGene(id string, min, max int)

+ type LocusGenePair struct

+ GeneID string

+ LocusID string

+ type LocusType int

+ const LocusBehavioral

+ const LocusConfig

+ const LocusParameter

+ const LocusSequence

+ type MigrationPolicy int

+ const PolicyBestReplaceWorst

+ const PolicyRandomReplaceRandom

+ type MigrationTopology int

+ const TopologyHypercube

+ const TopologyRandom

+ const TopologyRing

+ const TopologyStar

+ const TopologyTorus

+ type MultiIslandEngine struct

+ Config MultiIslandEngineConfig[Env, State]

+ Islands []*Engine[Env, State]

+ func NewMultiIslandEngine[Env any, State any](config MultiIslandEngineConfig[Env, State]) (*MultiIslandEngine[Env, State], error)

+ func (m *MultiIslandEngine[Env, State]) Run(def *Definition[Env, State]) (*Individual[Env, State], error)

+ type MultiIslandEngineConfig struct

+ EngineConfig EngineConfig[Env, State]

+ EnvFactory func(islandIndex int) Env

+ MigrationInterval int

+ MigrationPolicy MigrationPolicy

+ MigrationRate int

+ MigrationTopology MigrationTopology

+ NumIslands int

+ type MutationScheduleType int

+ const ScheduleCosineAnnealing

+ const ScheduleExponentialDecay

+ type Mutator interface

+ Mutate func(g Genome) Genome

+ type NSGA2Generation struct

+ func (s *NSGA2Generation[Env, State]) Initialize(e *Engine[Env, State]) error

+ func (s *NSGA2Generation[Env, State]) NextGeneration(e *Engine[Env, State], def *Definition[Env, State], ...) (Population[Env, State], error)

+ type ObjectiveDirection int

+ const Maximize

+ const Minimize

+ type OrderCrossover struct

+ func (c OrderCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type PMXCrossover struct

+ func (c PMXCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type Population []*Individual[Env, State]

+ func BestIndividualElitism[Env any, State any](pop Population[Env, State], size int) Population[Env, State]

+ func DefaultPopulationFunc[Env any, State any](def *Definition[Env, State], size int) Population[Env, State]

+ func TopNElitism[Env any, State any](pop Population[Env, State], size int) Population[Env, State]

+ func (p Population[Env, State]) AverageFitness() []float64

+ func (p Population[Env, State]) Best() *Individual[Env, State]

+ type PopulationFunc func(def *Definition[Env, State], size int) Population[Env, State]

+ type RankSelector struct

+ SelectionPressure float64

+ func (s RankSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s RankSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ type RechenbergController struct

+ DecreaseFactor float64

+ IncreaseFactor float64

+ Interval int

+ MaxScaler float64

+ MinScaler float64

+ TargetSuccessRatio float64

+ func NewRechenbergController[Env any, State any](interval int, targetSuccessRatio float64) *RechenbergController[Env, State]

+ func (c *RechenbergController[Env, State]) GetMutationScaler(e *Engine[Env, State]) float64

+ type RouletteWheelSelector struct

+ AutoShift bool

+ func (s RouletteWheelSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s RouletteWheelSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ type Selector interface

+ Select func(pop interface{}) interface{}

+ type SelfAdaptiveController struct

+ LearningRate float64

+ MaxRate float64

+ MinRate float64

+ func NewSelfAdaptiveController[Env any, State any](learningRate, minRate, maxRate float64) *SelfAdaptiveController[Env, State]

+ func (c *SelfAdaptiveController[Env, State]) GetMutationScaler(e *Engine[Env, State]) float64

+ type SequenceGenome []int

+ func (g SequenceGenome) Copy() Genome

+ func (g SequenceGenome) Size() int

+ type SequencingContext struct

+ BehavioralLoci []*Locus[Env, State]

+ SelectedGeneIDs []string

+ SelectedGeneIndices []int

+ type SigmoidDiversityFeedbackController struct

+ MaxScaler float64

+ MinScaler float64

+ Sensitivity float64

+ TargetDiversity float64

+ func NewSigmoidDiversityFeedbackController[Env any, State any](target, sensitivity, minS, maxS float64) *SigmoidDiversityFeedbackController[Env, State]

+ func (c *SigmoidDiversityFeedbackController[Env, State]) GetMutationScaler(e *Engine[Env, State]) float64

+ type SinglePointCrossover struct

+ func (c SinglePointCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type StandardGeneration struct

+ func (s *StandardGeneration[Env, State]) Initialize(e *Engine[Env, State]) error

+ func (s *StandardGeneration[Env, State]) NextGeneration(e *Engine[Env, State], def *Definition[Env, State], ...) (Population[Env, State], error)

+ type StochasticUniversalSamplingSelector struct

+ AutoShift bool

+ func (s *StochasticUniversalSamplingSelector[Env, State]) Select(pop interface{}) interface{}

+ func (s *StochasticUniversalSamplingSelector[Env, State]) SelectTyped(pop Population[Env, State]) *Individual[Env, State]

+ type SwapMutator struct

+ Probability float64

+ func (m SwapMutator) Mutate(g Genome) Genome

+ type TemporalScheduleController struct

+ CycleLength int

+ FinalRate float64

+ InitialRate float64

+ Type MutationScheduleType

+ func (c *TemporalScheduleController[Env, State]) GetMutationScaler(e *Engine[Env, State]) float64

+ type TournamentSelector struct

+ Size int

+ func (s TournamentSelector) Select(pop interface{}) interface{}

+ type TwoPointCrossover struct

+ func (c TwoPointCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type UniformCrossover struct

+ Probability float64

+ func (c UniformCrossover) Crossover(p1, p2 Genome) (Genome, Genome)

+ type WeightedCrossoverer struct

+ Crossoverer Crossoverer

+ Weight float64

+ type WeightedMutator struct

+ Mutator Mutator

+ Weight float64

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL