anchor.diff:              let F = 
                   match mutationF with
                       | Some(mutationF) -> mutationF
  -                    | None -> f
  +                    | None -> initialF
               let transform i v =
                   match i with
                       | _ when i=location -> F()
                       | _ -> v
               this.Genos <- List.mapi transform this.Genos 
   
  -        member this.ToRows() = [ this.Genos |> convert; this.Pheno |> convert ]
  +        member this.ToRows() = [ this.Genos |> List.map toInt; this.Pheno |> List.map toInt ]
   
       /// generate a population for GAs
  -    let Population randomF populationSize chromosomeSize = 
  -        [for i in 1..populationSize do yield (new ChromosomeType(f=randomF,size=chromosomeSize))] 
  +    let Population<'T,'S when 'S: comparison> randomF fitnessF toInt populationSize chromosomeSize = 
  +        [for i in 1..populationSize do yield (new ChromosomeType<'T,'S>(initialF=randomF,fitnessF=fitnessF,toInt=toInt,size=chromosomeSize))] 
   
       /// find the maximum fitness value from a population
  -    let maxFitness population fitnessF = 
  -        let best = Seq.maxBy (fun (c:ChromosomeType) -> c.Fitness(fitnessF)) population
  -        best.Fitness(fitnessF)
  +    let maxFitness<'T,'S when 'S: comparison> population  = 
  +        let best = Seq.maxBy (fun (c:ChromosomeType<'T,'S>) -> c.Fitness()) population
  +        best.Fitness()
   
  -    /// find the most fit individual
  -    let bestChromosome population fitnessF = 
  -        let best = Seq.maxBy (fun (c:ChromosomeType) -> c.Fitness(fitnessF)) population
  +    /// find the fittest individual
  +    let bestChromosome<'T,'S when 'S: comparison> population = 
  +        let best = Seq.maxBy (fun (c:ChromosomeType<'T,'S>) -> c.Fitness()) population
           best
   
       /// rank selection method
  -    let RankSelection (population:ChromosomeType list) fitnessFunction= 
  -        let populationSize = Seq.length population
  +    let RankSelection<'T,'S when 'S: comparison> (population:ChromosomeType<'T,'S> list) = 
  +        let populationSize = population.Length
           let r() = randomF() % populationSize
           let randomSelection() = 
               let c0 = population.[r()]
               let c1 = population.[r()]
  -            let result = if (c0.Fitness(fitnessFunction) > c1.Fitness(fitnessFunction)) then c0 else c1
  +            let result = if (c0.Fitness() > c1.Fitness()) then c0 else c1
               result.Clone();
           Seq.init populationSize (fun _ -> randomSelection())
   
       /// shuffle crossover
  -    let ShuffleCrossover (c0:ChromosomeType) (c1:ChromosomeType) =
  +    let ShuffleCrossover<'T,'S when 'S: comparison> (c0:ChromosomeType<'T,'S>) (c1:ChromosomeType<'T,'S>) =
           let crossover c0 c1 =
               let isEven n = n%2 = 0
               let randomSwitch (x,y) = if isEven (randomF()) then (x,y) else (y,x) 
  
positive.code: // System.Console.ReadKey() |> ignore
  
  /// Evolutionary computation module
  /// this module is for Genetic Algorithm(GA) only
  
  module EvolutionaryComputation =
  
      /// random number generator
      let random = new System.Random((int)System.DateTime.Now.Ticks)
  
  
negative.code:     /// random float (double) generator
      let randomFloatF() = random.NextDouble()
  
      type unitTo<'T> = unit -> 'T
      type ConvertersType<'T> = ('T -> 'T) list
      type FitnessType<'T,'S> = 'T list -> 'S 
  
      /// Chromosome type to represent the individuals involved in the GA
      type ChromosomeType<'T,'S when 'S: comparison> (initialF: unitTo<'T>, 
                                                      fitnessF: FitnessType<'T,'S>, 
                                                      toInt: 'T -> int, 
                                                      size, 
                                                      ?converters: ConvertersType<'T>) = 
          let mutable genos = [for i in 1..size do yield initialF()]
          let mutable genoPhenoConverters = converters
  
          /// make a duplicate copy of this chromosome
          member this.Clone() =
              let newValue = 
                  match converters with
                      | Some(converters) -> new ChromosomeType<'T,'S>(initialF, fitnessF, toInt, size, converters)
                      | None -> new ChromosomeType<'T,'S>(initialF, fitnessF, toInt, size)
              newValue.Genos <- this.Genos 
              newValue 
  
          /// get fitness value with given fitness function
          member this.Fitness() = this.Pheno |> fitnessF
  
          /// gets and sets the Geno values
          member this.Genos
  