anchor.diff:              and set(value) = genos <- value 
   
           /// gets and sets the Pheno values
  -        member this.Pheno 
  -            with get() = 
  +        member this.Pheno
  +            with get(): 'T list = 
                   match genoPhenoConverters with 
                   | Some(genoPhenoConverters) -> List.zip genoPhenoConverters genos |> List.map (fun (f,value) -> f value) 
                   | None -> this.Genos
  
positive.code:         c1.Genos <- second
          
      /// evolve the whole population 
      let Evolve (population:ChromosomeType list) selectionF crossoverF fitnessF crossoverRate mutationRate elitism = 
          let populationSize = Seq.length population 
          let r() = randomF() % populationSize 
          let elites = selectionF population fitnessF |> Seq.toList
          let seq0 = elites |> Seq.mapi (fun i element->(i,element)) |> Seq.filter (fun (i,_)->i%2=0) |> Seq.map (fun (_,b)->b)
          let seq1 = elites |> Seq.mapi (fun i element->(i,element)) |> Seq.filter (fun (i,_)->i%2<>0) |> Seq.map (fun (_,b)->b)
          let xoverAndMutate (a:ChromosomeType) (b:ChromosomeType) =
              if (randomFloatF() < crossoverRate) then 
                  crossoverF a b 
              if (randomFloatF() < mutationRate) then 
  
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
  