Генетический алгоритм построения алгоритмов

let initialPropertyValue = System.Double.Parse(System.Environment.GetCommandLineArgs().[1])
let targetPropertyValue = System.Double.Parse(System.Environment.GetCommandLineArgs().[2])
let targetPrecision = System.Double.Parse(System.Environment.GetCommandLineArgs().[3])
let iterationsNumber = System.Int32.Parse(System.Environment.GetCommandLineArgs().[4])

let actions = 
    [|  
        (fun (x: double) -> x - 1.0); 
        (fun (x: double) -> x); 
        (fun (x: double) -> x + 1.0); 
        (fun (x: double) -> x * 2.0); 
        (fun (x: double) -> -x); 
        (fun (x: double) -> x * x) 
    |]

type Action = double -> double
type Chromosome =  Action []
type Fitness = double
type Individual = Chromosome * Fitness

let populationSize = 5000 // bigger values better when actions number is big
let eliteSize = populationSize / 15 // bigger values makes search faster, but not exact
let populationIterations = populationSize // bigger values are better when functions are complex

let calculateFitness initialValue targetValue chromosome =
    let result = Array.fold (fun accumulator f -> f accumulator) initialValue chromosome
    abs(targetValue - result)

let getFitness = calculateFitness initialPropertyValue targetPropertyValue

let random = System.Random()

let createChromosome (initialActions: Action[]) size : Individual =
    let chromosome = Array.init<Action> size (fun _ ->  initialActions.[random.Next(0, initialActions.Length)] )
    let fitness = getFitness chromosome
    (chromosome, fitness)

let initializePopulation size initialChromosomeLength =
    Array.init<Individual> size (fun _ -> createChromosome actions initialChromosomeLength) 
    |> Array.sortBy (fun (_, fitness) -> fitness)

let getElite (population: Individual []) =
    let size = population.Length - eliteSize
    population.[..size]

let crossover (population: Individual []) =
    let top50percent = population.Length / 2
    let mom = fst population.[random.Next(top50percent)]
    let dad = fst population.[random.Next(top50percent)]
    let index = random.Next(min mom.Length dad.Length)
    let chromosome = Array.append mom.[..index] dad.[index + 1..]
    let fitness = getFitness chromosome
    (chromosome, fitness)

let newGeneration population =
    let elite = getElite population
    let withSize = population.Length - elite.Length
    Array.init<Individual> withSize (fun _ -> crossover population)
    |> Array.append elite
    |> Array.sortBy (fun (_, fitness) -> fitness)

let MatchAction functionIndex =
    match functionIndex with
    | 0 -> "decrement"
    | 1 -> "identity"
    | 2 -> "increment"
    | 3 -> "double"
    | 4 -> "negate"
    | 5 -> "square"
    | _ -> "unknown"
    |> (fun x -> x + " ")

let bestFitnessFor (population: Individual[]) =
    snd population.[0]

let formatBestOf (population: Individual []) =
    let result = fst population.[0] |> Array.fold (fun accumulator f -> f accumulator) initialPropertyValue
    let error = abs result - targetPropertyValue
     
    fst population.[0]
        |> Array.map(fun action -> Array.findIndex (fun f -> f.GetType().FullName = action.GetType().FullName) actions)
        |> Array.fold (fun accumulator value -> accumulator + MatchAction value) "functions sequence: "
        |> sprintf "Best with result %A and error %f is %s" result error

let evolve (population : Individual []) =

    let rec evolve (population : Individual []) n =
        match (n, (snd population.[0])) with
        | (0, _) -> population.[0]
        | (_, 0.0) -> population.[0]
        | _ ->
            let newPopulation = newGeneration population
            evolve newPopulation (n - 1)

    evolve population populationIterations

[<EntryPoint>]
let main args =
    printfn " -- The beginning -- "
    printfn "For %d iterations target %f from initial %f with precision %f" iterationsNumber (float targetPropertyValue) (float initialPropertyValue) (float targetPrecision) 

    seq { 1..iterationsNumber } 
        |> Seq.tryFind (fun chromosomeLength ->
            let population = initializePopulation populationSize chromosomeLength
            let best = evolve population
            let result = bestFitnessFor population
            if targetPrecision > result then formatBestOf population |> printfn "The best is %s"
            targetPrecision > result) 
        |> printfn "Length: %A"

    printfn " -- The ending -- "
    let executionResult = 0
    executionResult