Exemple #1
0
 public KrillHerdAlgorithm(KrillPopulation krillPopulation, FitnessFunction fitnessFunctionDelegate, Vector <double> LB_vector, Vector <double> UB_vector)
 {
     this.LB_vector  = LB_vector;
     this.UB_vector  = UB_vector;
     KrillPopulation = krillPopulation;
     FitnessFunction = fitnessFunctionDelegate;
 }
 public VirtualFood(KrillPopulation krillPopulation, FitnessFunction fitnessFunction, Vector <double> UB_Vector, Vector <double> LB_Vector)
 {
     this.UB_Vector  = UB_Vector;
     this.LB_Vector  = LB_Vector;
     KrillPopulation = krillPopulation;
     FitnessFunction = fitnessFunction;
     PositionOfFood  = Vector <double> .Build.Dense(krillPopulation.Population[0].Coordinates.Count);
 }
Exemple #3
0
        void Krill_OnGenerationComplete(object sender, RunEventArgs e)
        {
            KrillPopulation population = (KrillPopulation)sender;
            var             bestKrill  = population.GetBestKrill();

            Console.WriteLine("Iteration: {0}, Fitness: {1}, Coordinates: ({2}, {3})",
                              e.Iteration, Math.Round(bestKrill.Fitness, 4), Math.Round(bestKrill.Coordinates[0], 4), Math.Round(bestKrill.Coordinates[1], 4));
        }
 public InducedMotion(KrillPopulation KrillPopulation, FitnessFunction fitnessFunction, int maxIteration, double N_max)
     : base(KrillPopulation, fitnessFunction)
 {
     this.KrillPopulation = KrillPopulation;
     Neighbourhood        = new Neighbourhood(this.KrillPopulation);
     InducedSpeedHistory  = new Dictionary <Tuple <int, int>, Vector <double> >();
     MaxIteration         = maxIteration;
     this.N_max           = N_max;
 }
Exemple #5
0
        public ForagingMotion(KrillPopulation KrillPopulation, FitnessFunction fitnessFunction, int maxIteration, double V_f)
            : base(KrillPopulation, fitnessFunction)
        {
            F_i_old = Vector <double> .Build.Dense(KrillPopulation.Population[0].Coordinates.Count);

            this.V_f             = V_f;
            MaxIteration         = maxIteration;
            ForagingSpeedHistory = new Dictionary <Tuple <int, int>, Vector <double> >();
        }
Exemple #6
0
        private void PopulationInitialization()
        {
            // Population initialization
            List <Krill> Krills = new List <Krill>();

            for (int i = 1; i <= Parameters.Population; i++)
            {
                Krill krill = new Krill(i)
                {
                    Coordinates = Vector <double> .Build.Random(Parameters.Dimensions, new ContinuousUniform(Parameters.LB, Parameters.UB))
                };
                Krills.Add(krill);
            }

            Population = new KrillPopulation(Krills);
        }
        /// <summary>
        /// EQUATION 8
        /// </summary>
        private Vector <double> AlphaTarget(Krill krill, int currentIteration)
        {
            Krill bestKrill = KrillPopulation.GetBestKrill();

            if (bestKrill.Fitness > krill.Fitness)
            {
                double          K_i_best = K_i_j(krill.Fitness, bestKrill.Fitness);
                Vector <double> X_i_best = X_i_j(krill.Coordinates, bestKrill.Coordinates);
                double          C_best   = EffectiveCoefficient(currentIteration);

                return(X_i_best.Multiply(C_best * K_i_best));
            }
            else
            {
                return(Vector <double> .Build.Dense(krill.Coordinates.Count));
            }
        }
Exemple #8
0
        public void Run(int evaluations, double C_t, double N_max, double V_f, double D_max)
        {
            var               scaleVector       = CalculateScaleVector(C_t, UB_vector, LB_vector);
            InducedMotion     inducedMotion     = new InducedMotion(KrillPopulation, FitnessFunction, evaluations, N_max);
            ForagingMotion    foragingMotion    = new ForagingMotion(KrillPopulation, FitnessFunction, evaluations, V_f);
            VirtualFood       virtualFood       = new VirtualFood(KrillPopulation, FitnessFunction, UB_vector, LB_vector);
            PhysicalDiffusion physicalDiffusion = new PhysicalDiffusion(D_max, evaluations, scaleVector.Count);

            // We evaluate each krill in the population
            KrillPopulation.EvaluatePopulation(FitnessFunction);

            for (int i = 1; i <= evaluations; i++)
            {
                var vf_position = virtualFood.CreateVirtualFood();

                foreach (var krill in KrillPopulation.Population)
                {
                    Vector <double> N_i = inducedMotion.GetInducedMotion(krill, i);
                    Vector <double> F_i = foragingMotion.GetForagingMotion(krill, i, vf_position);
                    Vector <double> D_i = physicalDiffusion.GetPhysicalDiffusion(i);

                    Vector <double> X_i = (F_i + N_i).Add(D_i); // EQUATION 1
                    X_i = X_i.PointwiseMultiply(scaleVector);
                    var newPosition = krill.Coordinates + X_i;

                    var bestKrillPosition = KrillPopulation.GetBestKrill().Coordinates;
                    krill.Coordinates = MathHelpers.FindLimits(newPosition, bestKrillPosition, LB_vector, UB_vector);
                }

                // We evaluate each krill in the population
                KrillPopulation.EvaluatePopulation(FitnessFunction);

                OnGenerationComplete.Invoke(KrillPopulation, new RunEventArgs(i));
            }

            OnRunComplete.Invoke(KrillPopulation, new RunEventArgs(evaluations));
        }
 public Neighbourhood(KrillPopulation krillPopulation)
 {
     this.krillPopulation = krillPopulation;
 }
 public MotionBase(KrillPopulation KrillPopulation, FitnessFunction fitnessFunction)
 {
     this.KrillPopulation = KrillPopulation;
     FitnessFunction      = fitnessFunction;
 }
Exemple #11
0
        void Krill_OnRunComplete(object sender, RunEventArgs e)
        {
            KrillPopulation population = (KrillPopulation)sender;

            Console.WriteLine("Run complete");
        }