예제 #1
0
 public CartesianIndividual(CartesianIndividual other)
 {
     Name   = IndividualTools.CreateName();
     Values = new double[other.Values.Length];
     for (int i = 0; i < Values.Length; ++i)
     {
         Values[i] = other.Values[i];
     }
 }
예제 #2
0
파일: Helpers.cs 프로젝트: GKBelmonte/Core
        public static double EvaluateAckley(CartesianIndividual individual)
        {
            double sumOfSquares = individual.Values.Select(i => i * i).Sum();
            double sumOfCos     = individual.Values.Select(i => Math.Cos(2 * Math.PI * i)).Sum();
            double res          = -20 * Math.Exp(-0.2 * Math.Sqrt(0.5 * sumOfSquares))
                                  - Math.Exp(0.5 * sumOfCos)
                                  + 20;

            return((float)res);
        }
예제 #3
0
파일: Helpers.cs 프로젝트: GKBelmonte/Core
        private static double _EvaluatePolynomial(CartesianIndividual ind, double[] powersOfX)
        {
            double[] coefficients   = ind.Values;
            double   polynomialEval = 0;

            for (int j = 0; j < coefficients.Length; ++j)
            {
                polynomialEval += powersOfX[j] * coefficients[j];
            }

            return(polynomialEval);
        }
예제 #4
0
        public virtual IIndividual Mutate(float probability, float sigma, Random r)
        {
            var newInd = new CartesianIndividual(this);

            for (int i = 0; i < Values.Length; ++i)
            {
                if (r.ProbabilityPass(probability))
                {
                    newInd.Values[i] += r.GausianNoise(sigma);
                }
            }
            return(newInd);
        }
예제 #5
0
        //TODO: Fix for cartesian individuals of different sizes
        public static float Distance(CartesianIndividual a, CartesianIndividual b)
        {
            double res = 0;

            for (int i = 0; i < a.Values.Length && i < b.Values.Length; ++i)
            {
                double a_i  = i < a.Values.Length ? a.Values[i] : 0;
                double b_i  = i < b.Values.Length ? b.Values[i] : 0;
                double diff = b_i - a_i;
                res += diff * diff;
            }
            //not technically mandatory
            res = Math.Sqrt(res);
            return((float)res);
        }
예제 #6
0
        public static IIndividual CrossOver(List <IIndividual> parents, Random r)
        {
            var parent = (CartesianIndividual)parents[0];

            int newLength =
                parents
                .Select(i => ((CartesianIndividual)i).Values.Length)
                .ToList()
                .PickRandom();

            var newInd = new CartesianIndividual(newLength, r, empty: true);

            for (var ii = 0; ii < newLength; ++ii)
            {
                //33% chance of taking single random parent gene, 66% chance of taking average of all parents
                var dice = r.Next(0, 3);
                if (dice < 1)
                {
                    //Take average of parents respective alleles
                    double tot = 0.0f;
                    for (var kk = 0; kk < parents.Count; ++kk)
                    {
                        var par = (CartesianIndividual)parents[kk];
                        //TODO: is the absence of value zero?
                        if (ii < par.Values.Length)
                        {
                            tot += par.Values[ii];
                        }
                    }
                    //TODO: is the absence of value zero?
                    tot = tot / parents.Count;
                    newInd.Values[ii] = tot;
                }
                else //Take single parent gene randomly
                {
                    var par = (CartesianIndividual)parents[r.Next(0, parents.Count)];
                    //TODO: Is the absence of value zero?
                    newInd.Values[ii] = ii < par.Values.Length
                        ? par.Values[ii]
                        : 0;
                }
            }

            return(newInd);
        }
예제 #7
0
파일: Helpers.cs 프로젝트: GKBelmonte/Core
        /// <summary>
        /// Returns the mean-squared error of the individual if it's values
        /// represent the coefficients of a nth degree polynomial
        /// versus the expected values
        /// </summary>
        /// <param name="individual">The Cartesian individual made up of n+1 coefficients</param>
        /// <param name="powsOfXforAllX">First index represents the sample number (m).
        /// Second index represents the order of the coefficient x[m][n]
        /// e.g. : x[1][2] = x_1^2 where x_1 is the 1st sample
        /// </param>
        /// <param name="expectedVals">The expected values for the sample veing evaluated at that point y[m]</param>
        /// <returns></returns>
        public static float PolynomialEval(this CartesianIndividual individual, double[][] powsOfXforAllX, double[] expectedVals)
        {
            Debug.Assert(expectedVals.Length == powsOfXforAllX.Length);

            double score = EvaluatePolynomial(individual, powsOfXforAllX)
                           .Zip(expectedVals, (av, ev) =>
            {
                double diff = av - ev;
                return(diff * diff);
            })
                           .Sum();

            double mse = score / expectedVals.Length;

            if (double.IsPositiveInfinity(mse))
            {
                Debugger.Break();
            }

            return((float)Math.Log10(mse));
        }
예제 #8
0
파일: Helpers.cs 프로젝트: GKBelmonte/Core
 public static IEnumerable <double> EvaluatePolynomial(CartesianIndividual ind, double[][] powersOfXForAllX)
 {
     return(powersOfXForAllX.Select(pows => _EvaluatePolynomial(ind, pows)));
 }