private double[] Tablica(IFunkcje funkcja, int wymiar)
{
double[] punkty = new double[wymiar];
for (int i = 0; i < wymiar; i++)
{
punkty[i] = Punkt(funkcja.Min, funkcja.Max);
}
return(punkty);
}
private double[] InicjujPopulacje(IFunkcje funkcja, int wymiar)
{
double[] tablica = new double[wymiar];
for (int i = 0; i < wymiar; i++)
{
tablica[i] = Punkt(funkcja.Min, funkcja.Max);
}
return(tablica);
}
public double[] Algorytm(IFunkcje funkcja, int iloscKrokow, int wymiar)
{
int wielkoscPopulacji = 1000;
//Generacja populacji poczatkowej
//W petli
//Generowanie populacji potomnej => selekcja,krzyzowanie,mutacja
//Ocena
//https://towardsdatascience.com/introduction-to-genetic-algorithms-including-example-code-e396e98d8bf3
List <PunktyFunkcja> populacja = new List <PunktyFunkcja>();
for (int i = 0; i < wielkoscPopulacji; i++)
{
populacja.Add(new PunktyFunkcja(InicjujPopulacje(funkcja, wymiar)));
}
for (int i = 0; i < iloscKrokow; i++)
{
//Obliczenie wartosci funkcji z punktow w populacji
foreach (var x in populacja)
{
x.Wartosc = funkcja.ObliczFunkcje(x.Punkty);
}
//Posortowanie tablicy rosnaca
populacja = populacja.OrderBy(x => x.Wartosc).ToList();
//Wybranie x i usuniecie reszty
populacja.RemoveRange(30, wielkoscPopulacji - 30);
List <PunktyFunkcja> noweGeneracja = new List <PunktyFunkcja>();
while (populacja.Count + noweGeneracja.Count < wielkoscPopulacji)
{
//Crossover
//http://edu.pjwstk.edu.pl/wyklady/nai/scb/wyklad12/w12.htm
//http://www.rubicite.com/Tutorials/GeneticAlgorithms/CrossoverOperators/Order1CrossoverOperator.aspx
noweGeneracja.Add(Crossover(populacja));
}
populacja.AddRange(noweGeneracja);
noweGeneracja.Clear();
foreach (var x in populacja)
{
Mutacja(x);
}
}
foreach (var x in populacja)
{
x.Wartosc = funkcja.ObliczFunkcje(x.Punkty);
}
populacja = populacja.OrderBy(x => x.Wartosc).ToList();
return(populacja[0].Punkty);
}
public double[] Algorytm(IFunkcje funkcja, int iloscKrokow, int wymiar)
{
double[] lider = Tablica(funkcja, wymiar);
List <Particle> population = new List <Particle>();
for (int i = 0; i < numParticle; i++)
{
double[] position = Tablica(funkcja, wymiar);
double[] velocity = TablicaDruga(wymiar);
Particle particle = new Particle(position, velocity);
population.Add(particle);
if (funkcja.ObliczFunkcje(particle.BestKnow) < funkcja.ObliczFunkcje(lider))
{
Array.Clear(lider, 0, lider.Length);
lider = particle.Position;
}
}
for (int i = 0; i < iloscKrokow; i++)
{
foreach (Particle x in population)
{
for (int j = 0; j < wymiar; j++)
{
double r1 = random.NextDouble();
double r2 = random.NextDouble();
x.Velocity[j] = (w * x.Velocity[j]) + c1 * r1 * (x.BestKnow[j] - x.Position[j]) + c2 * r2 * (lider[j] * x.Position[j]);
}
for (int j = 0; j < wymiar; j++)
{
x.Position[j] += x.Velocity[j];
}
if (funkcja.ObliczFunkcje(x.Position) < funkcja.ObliczFunkcje(x.BestKnow))
{
x.BestKnow = x.Position;
}
if (funkcja.ObliczFunkcje(x.Position) < funkcja.ObliczFunkcje(lider))
{
Array.Clear(lider, 0, lider.Length);
lider = x.Position;
}
}
}
return(lider);
}
public double[] Algorytm(IFunkcje funkcja, int iloscKrokow, int wymiar)
{
List <double[]> populacja = new List <double[]>();
for (int i = 0; i < iloscAgentow; i++)
{
populacja.Add(UtworzAgenta(funkcja, wymiar));
}
for (int j = 0; j < iloscKrokow; j++)
{
for (int k = 0; k < populacja.Count; k++)
{
double[][] wybraniAgenci = DobierzAgentow(populacja, populacja[k]);
double[] y = new double[wymiar];
for (int i = 0; i < wymiar; i++)
{
double r = random.NextDouble();
if (r < CR)
{
y[i] = wybraniAgenci[0][i] + F * (wybraniAgenci[1][i] - wybraniAgenci[2][i]);
}
else
{
y[i] = populacja[k][i];
}
}
if (funkcja.ObliczFunkcje(y) <= funkcja.ObliczFunkcje(populacja[k]))
{
populacja[k] = y;
}
}
}
//Znalezienie najlepszego rozwiazania -> czyli najmniejsza wartosc funkcji
double[] najlepszeRozw = populacja[0];
foreach (double[] x in populacja)
{
if (funkcja.ObliczFunkcje(x) <= funkcja.ObliczFunkcje(najlepszeRozw))
{
najlepszeRozw = x;
}
}
return(najlepszeRozw);
}
public double[] Algorytm(IFunkcje funkcja, int iloscKrokow, int wymiar)
{
List <Robaczki> population = new List <Robaczki>();
for (int i = 0; i < populationNum; i++)
{
population.Add(new Robaczki(funkcja, Tablica(funkcja, wymiar)));
}
double[] lider = population.OrderBy(x => x.I).First().Position;
for (int i = 0; i < iloscKrokow; i++)
{
for (int j = 0; j < populationNum; j++)
{
for (int k = 0; k < populationNum; k++)
{
if (population[j].I > population[i].I)
{
for (int l = 0; l < wymiar; l++)
{
population[i].Position[l] += Attractiveness(population[i], population[j]) * (population[j].Position[l] - population[i].Position[l]);
population[i].Position[l] += gamma * (random.NextDouble() - 0.5);
if (population[i].Position[l] < funkcja.Min)
{
population[i].Position[l] = Punkt(funkcja.Min, funkcja.Max);
}
if (population[i].Position[l] > funkcja.Max)
{
population[i].Position[l] = Punkt(funkcja.Min, funkcja.Max);
}
}
}
}
}
//Odswiezenie wartosci funkcji
for (int l = 0; l < populationNum; l++)
{
population[l].I = funkcja.ObliczFunkcje(population[l].Position);
}
double[] temp = population.OrderBy(x => x.I).First().Position;
if (funkcja.ObliczFunkcje(temp) < funkcja.ObliczFunkcje(lider))
{
lider = temp;
}
}
return(lider);
}
public double[] Algorytm(IFunkcje funkcja, int iloscKrokow, int wymiar)
{
double coolingRate = 0.034;
double[] s = PunktStartowy(funkcja, wymiar);
double T = funkcja.Max;
for (int i = 0; i < iloscKrokow; i++)
{
double[] sNew = Sasiedzi(s, funkcja.Min, funkcja.Max, wymiar, Punkt(-0.1, 0.1));
if (AkceptowanePrawdopodobienstwo(energy(s, funkcja), energy(sNew, funkcja), T) > random.NextDouble())
{
s = sNew;
}
T *= 1 - coolingRate;
}
return(s);
}
private double[] RandomWalk(double[] cuckoo, IFunkcje funkcja)
{
double[] temp = new double[cuckoo.Length];
cuckoo.CopyTo(temp, 0);
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < cuckoo.Length; j++)
{
temp[j] += Punkt(-1.0, 1.0);
if (temp[j] < funkcja.Min)
{
temp[j] = Punkt(funkcja.Min, funkcja.Max);
}
if (temp[j] > funkcja.Max)
{
temp[j] = Punkt(funkcja.Min, funkcja.Max);
}
}
}
return(temp);
}
private double energy(double[] x, IFunkcje funkcja)
{
return(COEF * funkcja.ObliczFunkcje(x));
}
public Robaczki(IFunkcje funkcja, double[] position)
{
Position = position;
I = funkcja.ObliczFunkcje(Position);
}
public double[] Algorytm(IFunkcje funkcja, int iloscKrokow, int wymiar)
{
List <MyBat> population = new List <MyBat>();
for (int i = 0; i < populationNum; i++)
{
MyBat x = new MyBat(Tablica(funkcja, wymiar));
x.Frequency = Punkt(frequency[0], frequency[1]);
x.Loud = random.NextDouble();
x.ImpulsRatio = random.NextDouble();
x.Result = funkcja.ObliczFunkcje(x.Position);
population.Add(x);
}
//Znalezienie lidera stada => czyli nietoperz o najmniejszej wartosci funkcji
population = population.OrderBy(x => x.Result).ToList();
MyBat lider = population[0];
for (int i = 0; i < iloscKrokow; i++)
{
foreach (var x in population)
{
//Liczenie nowej czestotliwosci
x.Frequency = Punkt(frequency[0], frequency[1]);
//Liczenie predkosci czyli Velocity
//Aktualizacja polozenia
for (int j = 0; j < wymiar; j++)
{
x.Velocity[j] = x.Velocity[j] + (x.Position[j] - lider.Position[j]) * x.Frequency;
x.Position[j] = x.Position[j] + x.Velocity[j];
}
double[] bestPos = x.Position;
if (random.NextDouble() > x.ImpulsRatio)
{
for (int j = 0; j < wymiar; j++)
{
bestPos[j] = lider.Position[j] + (Punkt(-1, 1) * population.Average(y => y.Loud));
}
bestPos = RandomWalk(bestPos, funkcja);
}
if (funkcja.ObliczFunkcje(bestPos) < funkcja.ObliczFunkcje(x.Position) && random.NextDouble() < x.Loud)
{
x.Position = bestPos;
x.Loud = alfa * x.Loud;
x.ImpulsRatio = (1 - Math.Exp(-1 * gamma * x.ImpulsRatio));
}
x.Result = funkcja.ObliczFunkcje(x.Position);
if (funkcja.ObliczFunkcje(x.Position) < funkcja.ObliczFunkcje(lider.Position))
{
lider = x;
}
}
}
return(lider.Position);
}