mgo/mgo.evolution/breeding

breeding

object breeding
class Object
trait Matchable
class Any

Type members

Types

type Breeding[S, I, G] = (S, Vector[I], Random) => Vector[G]
type Crossover[S, P, O] = (S, P, Random) => O

A crossover is a function from some individuals (parents or mates, can be a single individual, a pair or a vector) to one or more genomes (even if more than one, all genomes are coming from crossing over the same parents).

A crossover is a function from some individuals (parents or mates, can be a single individual, a pair or a vector) to one or more genomes (even if more than one, all genomes are coming from crossing over the same parents).

The type P represent the parents, typically a single individual, a tuple, or a vector.

The type G can also represent more than one genome.

type GACrossover[S] = (S, (Vector[Double], Vector[Double])) => (Vector[Double], Vector[Double])
type GAMutation[S] = (S, Vector[Double]) => Vector[Double]
type Mutation[S, G1, G2] = (S, G1, Random) => G2

A mutation is a function from a single genome to another single genome

A mutation is a function from a single genome to another single genome

type Selection[S, I] = (S, Vector[I], Random) => I

** Selection ***

** Selection ***

Value members

Concrete methods

def binaryCrossover[S, V](rate: Int => Double): (S, (Vector[V], Vector[V])) => (Vector[V], Vector[V])
def blxC[S](alpha: Double): (S, (Vector[Double], Vector[Double])) => Vector[Double]
def breed[S, I, G](breeding: (S, I) => G, lambda: Int, reject: Option[G => Boolean]): (S, I) => G
def clonesReplace[S, I, G](cloneProbability: Double, population: Vector[I], genome: I => G, selection: S => I): (S, G) => G

Randomly replaces some of the genomes in gs by genomes taken from the original population of I

Randomly replaces some of the genomes in gs by genomes taken from the original population of I

def gaussianMutation[S](mutationRate: Int => Double, sigma: Double): () => S
def log2(x: Int): Int
def logOfPopulationSize(size: Int): Int
def randomMutation[S](mutationRate: Int => Double, discrete: Vector[D]): (S, Vector[Int]) => Vector[Int]
def randomSelection[S, I]: S => I
def sbxC[S](distributionIndex: Double): () => S

SBX RGA operator with Bounded Variable modification, see APPENDIX A p30 into :

SBX RGA operator with Bounded Variable modification, see APPENDIX A p30 into :

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.33.7291&rep=rep1&type=pdf

INPROCEEDINGS{Deb98anefficient, author = {Kalyanmoy Deb}, title = {An Efficient Constraint Handling Method for Genetic Algorithms}, booktitle = {Computer Methods in Applied Mechanics and Engineering}, year = {1998}, pages = {311--338} }

Notes : Deb implementation differs from NSGA2 he proposed on this site : http://www.iitk.ac.in/kangal/codes.shtml

Implementation based on http://repository.ias.ac.in/9415/1/318.pdf

def tournament[S, I, K : Order](ranks: Vector[K], rounds: Int => Int): S => I

Concrete fields

lazy
val log2_256: Int