public static Result HillClimb(BoardValues boardValues, int iteration = 1000)
{
Console.WriteLine("---HILLCLIMB---\n");
var randomBoard = Generator.GenerateRandomBoard(boardValues);
var currentResult = new Result(randomBoard, boardValues);
var newResult = new Result(currentResult);
//BoardHelper.Print(currentResult, "Generated random board:");
for (var i = 0; i < iteration; i++)
{
foreach (var neighbour in Generator.GenerateNeighbours(currentResult, boardValues))
{
if (currentResult.Error > neighbour.Error)
{
newResult = new Result(neighbour);
}
}
if (currentResult == newResult)
{
Console.WriteLine($"===End after {i} iteration===");
break;
}
currentResult = new Result(newResult);
}
return(currentResult);
}
public static (int iteration, int parameter) RunExperimentSimulatedAnnealing(BoardValues boardValues)
{
var iteration = 0;
var parameter = 0;
var repeat = 10;
while (true)
{
var sol = Method.SimulatedAnnealing(boardValues, iteration, parameter, write: false);
Console.WriteLine($"iteration: {iteration} - parameter {parameter} - error {sol.Error}");
if (sol.Error == 0)
{
--repeat;
if (repeat == 0)
{
break;
}
}
else
{
repeat = 10;
parameter += 100;
iteration += 50;
}
}
Console.WriteLine($"--- ITERATION: {iteration}, PARAMETER: {parameter} ---");
return(iteration, parameter);
}
public static Result GetRandomNeighbour(Result result, BoardValues boardValues)
{
var neighbours = GenerateNeighbours(result, boardValues);
var rnd = _random.Next(0, neighbours.Count);
return(neighbours[rnd]);
}
public static int CheckForErrors(BoardValues boardValues, bool[,] filledBoard)
{
var errors = 0;
void CountErrors(List <int>[] correctNumbers, List <int>[] filledNumbers, int dimension)
{
for (var i = 0; i < filledBoard.GetLength(dimension); i++)
{
var correctNumbersCount = correctNumbers[i].Count;
var filedNumbersCount = filledNumbers[i].Count;
if (correctNumbersCount == filedNumbersCount)
{
foreach (var(Correct, Filled) in correctNumbers[i].Zip(filledNumbers[i], (c, f) => (Correct: c, Filled: f)))
{
if (Correct != Filled)
{
errors += Math.Abs(Correct - Filled);
}
}
}
else if (correctNumbersCount == 0 ^ filedNumbersCount == 0)
{
foreach (var x in correctNumbersCount == 0 ? filledNumbers[i] : correctNumbers[i])
{
errors += x;
}
}
else
{
(List <int> longerList, int shorterListCount) = correctNumbersCount < filedNumbersCount ?
(filledNumbers[i], correctNumbersCount) : (correctNumbers[i], filedNumbersCount);
for (var j = 0; j < shorterListCount; j++)
{
if (correctNumbers[i][j] != filledNumbers[i][j])
{
errors += Math.Abs(correctNumbers[i][j] - filledNumbers[i][j]);
}
}
longerList.GetRange(shorterListCount, longerList.Count - shorterListCount).ForEach(x => {
errors += x;
});
}
}
}
var filledRowsNumbers = Generator.GenerateNumbers(filledBoard, dimension: 0);
var filledColumnsNumbers = Generator.GenerateNumbers(filledBoard, dimension: 1);
CountErrors(boardValues.RowsNumbers, filledRowsNumbers, dimension: 0);
CountErrors(boardValues.ColumnsNumbers, filledColumnsNumbers, dimension: 1);
return(errors);
}
public static Result IslandGenetic(BoardValues boardValues, int populationSize = 10, int iterationCount = 10, int islandCount = 5,
double crossoverPropability = 0.9, double mutationPropability = 0.1, string crossoverMethod = "OnePoint",
string selectionMethod = "Tournament", bool parallel = true)
{
Console.WriteLine("---ISLAND GENETIC---\n");
var genetic = new GeneticAlgorithm(boardValues, populationSize, iterationCount, islandCount, crossoverPropability, mutationPropability, crossoverMethod, selectionMethod, parallel);
return(genetic.Run(isIsland: true));
}
RunExperimentGenetic(BoardValues boardValues)
{
var iteration = 10;
var bestResult = new Result();
var bestParameters = (0, 0, 0.0, 0.0, "", "", "");
foreach (var crossoverMethod in new List <string>()
{
"OnePoint", "TwoPoints"
})
{
foreach (var selectionMethod in new List <string>()
{
"Rulet", "Rank", "Tournament"
})
{
foreach (var termConditionMethod in new List <string>()
{
"Iteration", "Mean", "Deviation"
})
{
for (var crossoverProp = 0.0; crossoverProp <= 1.0; crossoverProp += 0.1)
{
for (var mutationProp = 0.0; mutationProp <= 1.0; mutationProp += 0.1)
{
for (var popSize = 10; popSize <= 100; popSize += 10)
{
var result = Method.Genetic(boardValues, popSize, iteration, crossoverProp, mutationProp, crossoverMethod, selectionMethod, termConditionMethod);
Console.WriteLine($"Error {result.Error}\n\n");
Console.WriteLine($"Parameters {crossoverMethod} {selectionMethod} {termConditionMethod} {crossoverProp} {mutationProp} {popSize}");
if (bestResult.Board == null)
{
bestResult = new Result(result);
}
if (bestResult.Error > result.Error)
{
bestResult = new Result(result);
bestParameters = (popSize, iteration, crossoverProp, mutationProp, crossoverMethod, selectionMethod, termConditionMethod);
}
}
}
}
}
}
}
return(bestParameters);
}
public static List <Result> GenerateNeighbours(Result result, BoardValues boardValues)
{
var neighbours = new List <Result>();
for (var i = 0; i < result.Board.GetLength(0); i++)
{
for (var j = 0; j < result.Board.GetLength(1); j++)
{
var newBoard = result.Board.Clone() as bool[, ];
newBoard[i, j] = !newBoard[i, j];
neighbours.Add(new Result(newBoard, boardValues));
}
}
return(neighbours);
}
public static void ParallelVsNotParallel(BoardValues boardValues)
{
var parallel = new List <Result>();
var notParallel = new List <Result>();
for (var i = 0; i < 40; i++)
{
var watch = Stopwatch.StartNew();
var result = Method.Genetic(boardValues, 1000, 500, 0.4, 0.5, "OnePoint", "Tournament", "Iteration", i % 2 == 0);
watch.Stop();
result.Time = watch.ElapsedMilliseconds / 1000f;
if (i % 2 == 0)
{
parallel.Add(result);
}
else
{
notParallel.Add(result);
}
}
Console.WriteLine("----- PARALLEL -----|----- NOT PARALLEL -----");
for (var i = 0; i < parallel.Count; i++)
{
Console.WriteLine($"Time:{parallel[i].Time} Error:{parallel[i].Error} | " +
$"Time:{notParallel[i].Time} Error:{notParallel[i].Error}");
}
Console.WriteLine("--------------------|------------------------");
var pTimeSum = 0f;
var pErrorSum = 0;
var nTimeSum = 0f;
var nErrorSum = 0;
for (var i = 0; i < parallel.Count; i++)
{
pTimeSum += parallel[i].Time;
pErrorSum += parallel[i].Error;
nTimeSum += notParallel[i].Time;
nErrorSum += notParallel[i].Error;
}
Console.WriteLine($"Time:{pTimeSum / parallel.Count} Error:{pErrorSum / parallel.Count} | " +
$"Time:{nTimeSum / parallel.Count} Error:{nErrorSum / parallel.Count}");
}
public static bool[,] GenerateRandomBoard(BoardValues boardValues)
{
var n = boardValues.RowCount;
var m = boardValues.ColumnCount;
var board = new bool[n, m];
for (var i = 0; i < n; i++)
{
for (var j = 0; j < m; j++)
{
board[i, j] = _random.Next(0, 10) % 2 != 0;
}
}
return(board);
}
public static Result SimulatedAnnealing(BoardValues boardValues, int iteration = 10000, double parameter = 40000.0, bool write = true, Func <int, double> T = null)
{
Console.WriteLine("---SIMULATEDANNEALING---\n");
if (T == null)
{
T = x => { return(parameter / x); }
}
;
var s = new List <Result>();
var randomBoard = Generator.GenerateRandomBoard(boardValues);
var currentResult = new Result(randomBoard, boardValues);
s.Add(currentResult);
for (var k = 0; k < iteration; k++)
{
var newSolution = Generator.GetRandomNeighbour(s.Last(), boardValues);
if (newSolution.Error < s.Last().Error)
{
s.Add(newSolution);
}
else
{
double u = new Random().NextDouble();
var tkError = newSolution.Error;
var skError = s.Last().Error;
s.Add(u < Math.Exp(-Math.Abs(tkError - skError) / T(k)) ? newSolution : s.Last());
}
if (write && k % 100 == 0)
{
Console.WriteLine($"iteracja {k} - error {s.Last().Error}");
}
}
return(s.Find(result => result.Error == s.Min(minResult => minResult.Error)));
}
public static Result BruteForce(BoardValues boardValues)
{
Console.WriteLine("---BRUTEFORCE---\n");
var bestBoard = new bool[boardValues.RowCount, boardValues.ColumnCount];
var minError = int.MaxValue;
Parallel.ForEach(Generator.GenerateCombinations(boardValues.RowCount, boardValues.ColumnCount), board =>
{
var error = BoardHelper.CheckForErrors(boardValues, board);
if (error < minError)
{
minError = error;
bestBoard = board;
}
});
return(new Result(bestBoard, boardValues));
}
public static Result Tabu(BoardValues boardValues, int iteration = 1000, int tabuSize = 100)
{
Console.WriteLine("---TABU---\n");
var tabuList = new List <Result>();
var randomBoard = Generator.GenerateRandomBoard(boardValues);
var currentResult = new Result(randomBoard, boardValues);
tabuList.Add(currentResult);
var globalBest = tabuList.Last();
//BoardHelper.Print(currentResult, "Generated random board:");
for (var i = 0; i < iteration; i++)
{
var neighbours = Generator.GenerateNeighbours(tabuList.Last(), boardValues);
tabuList.ForEach(t =>
{
neighbours.RemoveAll(x => x == t);
});
if (neighbours.Count <= 0)
{
if (tabuList.Count > 1)
{
tabuList.RemoveAt(0);
}
else
{
return(globalBest);
}
}
else
{
var currentBest = neighbours.Last();
foreach (var neighbour in neighbours)
{
if (neighbour.Error < currentBest.Error)
{
currentBest = new Result(neighbour);
}
}
tabuList.Add(currentBest);
if (currentBest.Error < globalBest.Error)
{
globalBest = new Result(currentBest);
}
if (tabuList.Count >= tabuSize)
{
tabuList.RemoveAt(0);
}
}
}
return(globalBest);
}
