F# Artificial Intelligence Library - An Implementation of Selected AI Methods

namespace Rnd
{
    public static partial class Globals
    {
        public static RandomOps.Ran2 Random = new RandomOps.Ran2();
    }

namespace Rnd
{
    public static partial class Globals
    {
        public static RandomOps.Ran2 Random = new RandomOps.Ran2();
    }

    public static class RandomNumber
    {
        public static double GetRandom(double min, double max)
        {
            return Globals.Random.Uniform(min, max);
        }
    }
}

// Path where libraries are placed
#I @"C:\fsai"

// Reference to main library
#r "FSharp.AI.dll"

// Loading of F# module
#load "TestFunctions.fs"

// Opening of namespace and module
open FSharp.AI
open TestFunctions

//
//  Initialization of Differential Evolution
//
// Mutation constant
let f = 0.9
// Cross-over value
let cr = 0.2
// Number of population
let np = 60
// Number of generations
let generations = 60
// Type of Differential Evolution
let typ = DEVariant.DERand1Bin

//
//  Definition of Specimen
//  ------------------------
//  Each argument has specified type (int or float) and minimum - maximum values.
//  In this case the specimen has two arguments. Both arguments have defined range <-5; 5> of float type.
//
let Specimen = [
    new SpecimenArgument (typeof<float>, -5., 5.)
    new SpecimenArgument (typeof<float>, -5., 5.) ]

//
//  Definition of Cost Function
//  -----------------------------
//  This function provides evaluation of individuals.
//  The structure of this function cannot be changed, but computation of cost value.
//
let CostFunction (individual : float[]) : float[] = 
    // Cost value
    let mutable cv = 0.
    //---------------------------------
    // This part should contain computation of cost value and can be changed.

    // Example of using test function
    // individual.[1] - accessing first argument of individual - defined in accordance to first argument of specimen
    // individual.[2] - accessing second argument of individual - defined in accordance to second argument of specimen
    cv <- DeJong1st [individual.[1]; individual.[2]]
    //----------------------------------
    individual.[0] <- cv
    individual

// Creating Object
let evolution = new DE()
// Running evolution
let (result, progress) = evolution.RunEvolution (f, cr, np, generations, Specimen, typ, CostFunction)

// Result variable contains individuals of the last generation. Following code selects an individual with minimal cost value.
// First printed number is the cost value, others are arguments of individuals
printfn "%A" (Array.min result)

// Cost values of best individuals over all generations
printfn "%A" progress

System.Console.ReadKey()

using System;
using System.Collections.Generic;
using System.Text;
using FSharp.AI;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //
            // Initialization of Differential Evolution
            //
            // Mutation constant
            double f = 0.9;
            // Cross-over value
            double cr = 0.2;
            // Number of population
            int np = 60;
            // Number of generations
            int generations = 60;
            // Type of Differential Evolution
            DEVariant typ = DEVariant.DERand1Bin;

            //
            // Definition of Specimen
            // -----------------------
            // Each argument has specified type (int or double) and minimum - maximum values.
            // In this case the specimen has two arguments. Both arguments have defined range <-5; 5> of double type.
            //
            List<SpecimenArgument> Specimen = new List<SpecimenArgument>()
            {
                new SpecimenArgument(typeof(double), -5, 5),
                new SpecimenArgument(typeof(double), -5, 5)
            };

            // Delegate of Cost Function method
            Func<double[], double[]> CostFunction = CF;
            
            // Creating DE object
            DE evoluce = new DE();

            // Running evolution
            Tuple<double[][], double[]> vysledek = evoluce.RunEvolution(f, cr, np, generations, Specimen, typ, CostFunction);

            // Finding best individual (C# doesn't contain Array.min)
            double[] nejlepsi = FindBestOne(vysledek.Item1);

            // Printing results
            StringBuilder sb = new StringBuilder();
            sb.Append("CV: ");
            sb.Append(nejlepsi[0].ToString());
            sb.Append("; argumenty: ");
            for (int i = 1; i < nejlepsi.Length; i++)
            {
                sb.Append(nejlepsi[i].ToString());
                sb.Append(";");
            }
            Console.WriteLine(sb.ToString());
            Console.ReadKey();            
        }

        // Cost Function
        static double[] CF(double[] individual)
        {
            double cv = 0;

            // Implementation of 1st de Jong function
            for (int i = 1; i < individual.Length; i++)
            {
                cv += (individual[i] * individual[i]);
            }

            individual[0] = cv;

            return individual;
        }

        // This method finds best individual
        static double[] FindBestOne(double[][] generace)
        {
            double[] bestOne = generace[0];

            for (int i = 1; i < generace.Length; i++)
            {
                if (generace[i][0] < bestOne[0])
                {
                    bestOne = generace[i];
                }
            }

            return bestOne;
        }

    }
}