public void SimpleTest5()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9000, 100, new List <Item>
{
new Item(27, 38, 0),
new Item(2, 86, 1),
new Item(41, 112, 2),
new Item(1, 0, 3),
new Item(25, 66, 4),
new Item(1, 97, 5),
new Item(34, 195, 6),
new Item(3, 85, 7),
new Item(50, 42, 8),
new Item(12, 223, 9)
});
IKnapsackSolver solver = new BruteForceSolver();
int solve = solver.Solve(problem);
Assert.AreEqual(798, solve);
IKnapsackSolver solver2 = new BranchAndBoundSolver();
int solve2 = solver2.Solve(problem);
Assert.AreEqual(798, solve2);
IKnapsackSolver solver3 = new DynamicByCostSolver();
int solve3 = solver3.Solve(problem);
Assert.AreEqual(798, solve3);
}
public void Solve_ShouldReturnCorrectValue_IfAllItemsShouldBeInBag()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9005, 100, new List <Item>
{
new Item(12, 66, 0), new Item(52, 167, 1), new Item(14, 150, 2), new Item(3, 180, 3)
});
IKnapsackSolver solver = new RatioHeuristicSolver();
int solve = solver.Solve(problem);
Assert.AreEqual(563, solve);
IKnapsackSolver solver2 = new BruteForceSolver();
int solve2 = solver2.Solve(problem);
Assert.AreEqual(563, solve2);
IKnapsackSolver solver3 = new BranchAndBoundSolver();
int solve3 = solver3.Solve(problem);
Assert.AreEqual(563, solve3);
IKnapsackSolver solver4 = new DynamicByCostSolver();
int solve4 = solver4.Solve(problem);
Assert.AreEqual(563, solve4);
}
public double GetMaximumError(KnapsackProblemModel problem)
{
var n = problem.Items.Count;
var cMax = problem.Items.Max(item => item.Cost);
return((n * Math.Pow(2, GetBitesShift(problem))) / cMax);
}
public int Solve(KnapsackProblemModel problem)
{
List <Item> items = problem.Items.ToList();
items.Sort((item, item1) => item.ItemId - item1.ItemId);
// Price, ItemId, Weight
DecompositionTable decompositionTable = new DecompositionTable
{
//W(0,0) = 0
{ 0, new Dictionary <int, int> {
{ -1, 0 }
} }
};
int maxCost = items.Sum(item => item.Cost);
while (true)
{
int weight = GetValueFromDecompositionTable(decompositionTable, items, items.Count - 1, maxCost);
if (weight <= problem.BagCapacity)
{
return(maxCost);
}
maxCost--;
}
}
public void SimpleTest()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9000, 100, new List <Item>
{
new Item(18, 114, 0), new Item(42, 136, 1), new Item(88, 192, 2), new Item(3, 223, 3)
});
IKnapsackSolver solver = new BruteForceSolver();
int solve = solver.Solve(problem);
Assert.AreEqual(473, solve);
IKnapsackSolver solver2 = new BranchAndBoundSolver();
int solve2 = solver2.Solve(problem);
Assert.AreEqual(473, solve2);
IKnapsackSolver solver4 = new GeneticSolver(100, 100, new RouletteWheelSelection(), 0.01, 0.8, 0, false, false);
solver4.Solve(problem);
IKnapsackSolver solver5 = new FPTASSolver(0.9);
solver5.Solve(problem);
}
public int Solve(KnapsackProblemModel problem)
{
List <Item> items = problem.Items.ToList();
items.Sort((item, item1) => item.ItemId - item1.ItemId);
// Price, ItemId, Weight
DecompositionTable decompositionTable = new DecompositionTable
{
//W(0,0) = 0
{ 0, new Dictionary <int, int> {
{ -1, 0 }
} }
};
DecompositionTable result = new DecompositionTable
{
{ 0, new Dictionary <int, int> {
{ -1, -1 }
} }
};
List <Item> itemsShifted = new List <Item>();
//FPTAS SHIFT
int bitesShift = GetBitesShift(problem);
foreach (var item in items)
{
itemsShifted.Add(new Item(item.Weight, item.Cost >> bitesShift, item.ItemId));
}
int maxCost = itemsShifted.Sum(item => item.Cost);
int maxItemId = itemsShifted.Count - 1;
while (true)
{
int weight = GetValueFromDecompositionTable(decompositionTable, itemsShifted, maxItemId, maxCost, result);
if (weight <= problem.BagCapacity)
{
int realCost = 0;
int actualCost = maxCost;
for (int i = maxItemId; i >= 0; i--)
{
if (result[actualCost][i] == 1)
{
int realItemCost = items[i].Cost;
int shiftedCost = itemsShifted[i].Cost;
realCost += realItemCost;
actualCost -= shiftedCost;
}
}
return(realCost);
}
maxCost--;
}
}
public int Solve(KnapsackProblemModel problem)
{
Bag bag = new Bag(problem.BagCapacity);
List <Item> items = problem.Items.ToList();
return(RecursiveSolver(bag, items, 0));
}
private int GetBitesShift(KnapsackProblemModel problem)
{
int n = problem.Items.Count;
int cMax = problem.Items.Max(item => item.Cost);
double bitesShift = Math.Log((((1 - _precision) * cMax) / n), 2);
int floor = (int)Math.Floor(bitesShift);
return(floor < 0 ? 0 : floor);
}
public int Solve(KnapsackProblemModel problem)
{
Bag bag = new Bag(problem.BagCapacity);
List <Item> items = problem.Items.ToList();
int count = items.Count;
BitArray possibility = new BitArray(count);
int bestItemsCost = 0;
while (true)
{
for (int i = 0; i < count; i++)
{
//NEXT BIT WILL BE INVERTED
bool next = !possibility[i];
possibility[i] = next;
//IF NEW VALUE IS TRUE INSERT ITEM - IF FALSE REMOVE IT
if (next)
{
bag.InsertItem(items[i]);
}
else
{
bag.RemoveItem(items[i]);
}
//ONE IS SET - END
if (next)
{
break;
}
}
if (bag.IsEmpty())
{
break;
}
if (bag.AcceptableWeight())
{
int itemsCost = bag.ItemsCost();
if (itemsCost > bestItemsCost)
{
bestItemsCost = itemsCost;
}
}
}
return(bestItemsCost);
}
public void SimpleTest2()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9000, 100, new List <Item>
{
new Item(89, 196, 0), new Item(18, 62, 1), new Item(57, 34, 2), new Item(69, 112, 3)
});
IKnapsackSolver solver = new RatioHeuristicSolver();
int solve = solver.Solve(problem);
//Assert.AreEqual(473, solve);
}
public void ParseProblem_ShouldReturnCorrectResult_IfCorrectDataArePassed()
{
const string data = "9000 4 100 18 114 42 136 88 192 3 223";
StringReader stringReader = new StringReader(data);
DataParser parser = new DataParser();
IEnumerable <KnapsackProblemModel> knapsackProblemModels = parser.ParseProblem(stringReader);
List <KnapsackProblemModel> problemModels = knapsackProblemModels.ToList();
KnapsackProblemModel parsedModel = problemModels[0];
KnapsackProblemModel refereceModel = new KnapsackProblemModel(9000, 100, new List <Item>
{
new Item(18, 114, 0), new Item(42, 136, 1), new Item(88, 192, 2), new Item(3, 223, 3)
});
Assert.AreEqual(refereceModel, parsedModel);
}
public int Solve(KnapsackProblemModel problem)
{
List <Item> items = problem.Items.ToList();
items.Sort(Item.CostToWeightRatioComparerDescending);
Bag bag = new Bag(problem.BagCapacity);
foreach (Item t in items)
{
bag.InsertItem(t);
if (!bag.AcceptableWeight())
{
bag.RemoveItem(t);
}
}
return(bag.ItemsCost());
}
public void SimpleTestWithZeroElem()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9000, 100, new List <Item>
{
new Item(18, 0, 0), new Item(42, 136, 1), new Item(88, 0, 2), new Item(3, 223, 3)
});
IKnapsackSolver solver = new BruteForceSolver();
int solve = solver.Solve(problem);
Assert.AreEqual(359, solve);
IKnapsackSolver solver2 = new BranchAndBoundSolver();
int solve2 = solver2.Solve(problem);
Assert.AreEqual(359, solve2);
IKnapsackSolver solver3 = new DynamicByCostSolver();
int solve3 = solver3.Solve(problem);
Assert.AreEqual(359, solve3);
}
public void SimpleTest4()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9012, 100, new List <Item>
{
new Item(51, 87, 0), new Item(5, 198, 1), new Item(19, 40, 2), new Item(81, 47, 3)
});
IKnapsackSolver solver = new BruteForceSolver();
int solve = solver.Solve(problem);
Assert.AreEqual(325, solve);
IKnapsackSolver solver2 = new BranchAndBoundSolver();
int solve2 = solver2.Solve(problem);
Assert.AreEqual(325, solve2);
IKnapsackSolver solver3 = new DynamicByCostSolver();
int solve3 = solver3.Solve(problem);
Assert.AreEqual(325, solve3);
}
public void SimpleTest3()
{
KnapsackProblemModel problem = new KnapsackProblemModel(9013, 100, new List <Item>
{
new Item(11, 166, 0), new Item(24, 165, 1), new Item(50, 74, 2), new Item(21, 100, 3)
});
IKnapsackSolver solver = new BruteForceSolver();
int solve = solver.Solve(problem);
Assert.AreEqual(431, solve);
IKnapsackSolver solver2 = new BranchAndBoundSolver();
int solve2 = solver2.Solve(problem);
Assert.AreEqual(431, solve2);
IKnapsackSolver solver3 = new DynamicByCostSolver();
int solve3 = solver3.Solve(problem);
Assert.AreEqual(431, solve3);
}
static void Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();
decimal frequency = Stopwatch.Frequency;
if (CommandLine.Parser.Default.ParseArguments(args, Options))
{
TextWriter reportWriter = Options.OutputFilePath == null ? Console.Out : new StreamWriter(Options.OutputFilePath);
VerboseLog("Data parsing ...");
DataParser parser = new DataParser();
List <KnapsackProblemModel> knapsackProblemModels = parser.ParseProblem(Options.InputFiles);
Dictionary <int, int> knownResults = null;
Dictionary <int, Tuple <int, long> > bruteForceResults = new Dictionary <int, Tuple <int, long> >();
Dictionary <int, Tuple <int, long> > costToRatioHeuristicsResults = new Dictionary <int, Tuple <int, long> >();
Dictionary <int, Tuple <int, long> > branchAndBoundResults = new Dictionary <int, Tuple <int, long> >();
Dictionary <int, Tuple <int, long> > dynamicByCostResults = new Dictionary <int, Tuple <int, long> >();
Dictionary <int, Tuple <int, long> > fptasResults = new Dictionary <int, Tuple <int, long> >();
Dictionary <int, Tuple <int, long> > geneticResults = new Dictionary <int, Tuple <int, long> >();
if (Options.ResultFiles != null)
{
knownResults = parser.ParseResults(Options.ResultFiles);
}
VerboseLog("Done.");
IKnapsackSolver bruteForceSolver = new BruteForceSolver();
IKnapsackSolver ratioHeuristicSolver = new RatioHeuristicSolver();
IKnapsackSolver branchAndBoundSolver = new BranchAndBoundSolver();
IKnapsackSolver dynamicByCostSolve = new DynamicByCostSolver();
IKnapsackSolver fptasSolver = null;
IKnapsackSolver geneticSolver = null;
if (Options.FPTAS)
{
fptasSolver = new FPTASSolver(Options.FPTASAccuracy);
}
if (Options.Genetics)
{
ISelectionMethod selectionMethod = null;
switch (Options.SelectionMethod)
{
case "roulette": selectionMethod = new RouletteWheelSelection();
break;
case "rank": selectionMethod = new RankSelection();
break;
case "elitary": selectionMethod = new EliteSelection();
break;
default: Console.WriteLine("Wrong selection method for genetics");
break;
}
if (selectionMethod == null)
{
return;
}
if (Options.GeneticMetaoptimization)
{
//Random selection portion
for (int i = 0; i < 100; i++)
{
double randomSelectionPortion = (i * 0.001) + 0;
//Crossover rate
for (int j = 0; j < 1; j++)
{
double crossoverRate = (j * 0.03) + 0.22;
//Mutation rate
for (int k = 0; k < 1; k++)
{
double mutationRate = (k * 0.04) + 0.87;
geneticSolver = new GeneticSolver(Options.PopulationSize, Options.IterationsCount, selectionMethod, mutationRate, crossoverRate, randomSelectionPortion, false, false);
geneticResults.Clear();
foreach (KnapsackProblemModel problem in knapsackProblemModels)
{
int result = 0;
try
{
stopwatch.Restart();
result = geneticSolver.Solve(problem);
stopwatch.Stop();
}
catch (Exception ex)
{
}
geneticResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
}
decimal totalTime = 0;
decimal totalError = 0;
foreach (KnapsackProblemModel problem in knapsackProblemModels)
{
int problemId = problem.ProblemId;
Tuple <int, long> result = geneticResults[problemId];
totalTime += (result.Item2 / frequency);
totalError += CalculateRelativeError(knownResults[problemId], result.Item1);
}
decimal averageError = totalError / knapsackProblemModels.Count;
reportWriter.WriteLine(randomSelectionPortion + "," + crossoverRate + "," + mutationRate + "," + totalTime + "," + averageError);
}
}
}
}
geneticSolver = new GeneticSolver(Options.PopulationSize, Options.IterationsCount, selectionMethod, Options.MutationRate, Options.CrossoverRate, Options.RandomSelectionPortion, Options.DiversityCheck, true);
}
VerboseLog("Solving JIT instance");
KnapsackProblemModel jitProblem = new KnapsackProblemModel(-1, 100, new List <Item>
{
new Item(18, 114, 0), new Item(42, 136, 1), new Item(88, 192, 2), new Item(3, 223, 3)
});
bruteForceSolver.Solve(jitProblem);
ratioHeuristicSolver.Solve(jitProblem);
branchAndBoundSolver.Solve(jitProblem);
dynamicByCostSolve.Solve(jitProblem);
if (fptasSolver != null)
{
fptasSolver.Solve(jitProblem);
}
if (geneticSolver != null)
{
geneticSolver.Solve(jitProblem);
}
VerboseLog("Calculation started");
foreach (KnapsackProblemModel problem in knapsackProblemModels)
{
VerboseLog("Solving problem:");
VerboseLog(problem);
int knownResult = -1;
if (knownResults != null)
{
knownResult = knownResults[problem.ProblemId];
VerboseLog("Result should be: " + knownResult);
}
if (Options.BruteForce)
{
VerboseLog("Brute force solver ...");
stopwatch.Restart();
int result = bruteForceSolver.Solve(problem);
stopwatch.Stop();
bruteForceResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
if (knownResult != -1 && result != knownResult)
{
Console.WriteLine("ERROR - Brute force algorithm not accurate for problem " + problem);
Environment.Exit(1);
}
}
if (Options.BranchAndBound)
{
VerboseLog("Branch and bound solver ...");
stopwatch.Restart();
int result = branchAndBoundSolver.Solve(problem);
stopwatch.Stop();
branchAndBoundResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
if (knownResult != -1 && result != knownResult)
{
Console.WriteLine("ERROR - Branch and bound algorithm not accurate for problem " + problem);
Environment.Exit(1);
}
}
if (Options.DynamicByCost)
{
VerboseLog("Dynamic by cost solver ...");
stopwatch.Restart();
int result = dynamicByCostSolve.Solve(problem);
stopwatch.Stop();
dynamicByCostResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
if (knownResult != -1 && result != knownResult)
{
Console.WriteLine("ERROR - Dynamic by cost algorithm not accurate for problem " + problem);
Environment.Exit(1);
}
}
if (Options.CostToRatioHeuristics)
{
VerboseLog("Ratio heuristics solver ...");
stopwatch.Restart();
int result = ratioHeuristicSolver.Solve(problem);
stopwatch.Stop();
costToRatioHeuristicsResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
}
if (Options.FPTAS)
{
VerboseLog("FPTAS solver ...");
if (fptasSolver != null)
{
stopwatch.Restart();
int result = fptasSolver.Solve(problem);
stopwatch.Stop();
fptasResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
}
}
if (Options.Genetics)
{
VerboseLog("Genetics solver ...");
if (geneticSolver != null)
{
stopwatch.Restart();
int result = geneticSolver.Solve(problem);
stopwatch.Stop();
geneticResults.Add(problem.ProblemId, new Tuple <int, long>(result, stopwatch.ElapsedTicks));
}
}
VerboseLog("Problem solved.");
}
reportWriter.Write("Problem ID;Items count");
if (knownResults != null)
{
reportWriter.Write(";Known result");
}
if (Options.BruteForce)
{
reportWriter.Write(";Brute force result;Time [s]");
if (knownResults != null)
{
reportWriter.Write(";Relative error");
}
}
if (Options.CostToRatioHeuristics)
{
reportWriter.Write(";Cost to weight ration heuristics result;Time [s]");
if (knownResults != null)
{
reportWriter.Write(";Relative error");
}
}
if (Options.BranchAndBound)
{
reportWriter.Write(";Branch and bound result;Time [s]");
if (knownResults != null)
{
reportWriter.Write(";Relative error");
}
}
if (Options.DynamicByCost)
{
reportWriter.Write(";Dynamic programming by cost result;Time [s]");
if (knownResults != null)
{
reportWriter.Write(";Relative error");
}
}
if (Options.FPTAS)
{
reportWriter.Write(";FPTAS result;Time [s]");
if (knownResults != null)
{
reportWriter.Write(";Relative error;Max possible error");
}
}
if (Options.Genetics)
{
reportWriter.Write(";Genetics result;Time [s]");
if (knownResults != null)
{
reportWriter.Write(";Relative error");
}
}
reportWriter.WriteLine();
foreach (KnapsackProblemModel problem in knapsackProblemModels)
{
var problemId = problem.ProblemId;
reportWriter.Write(problemId);
reportWriter.Write(";" + problem.Items.Count);
if (knownResults != null)
{
reportWriter.Write(";" + knownResults[problemId]);
}
if (Options.BruteForce)
{
Tuple <int, long> bruteForceResult = bruteForceResults[problemId];
reportWriter.Write(";" + bruteForceResult.Item1 + ";" + bruteForceResult.Item2 / frequency);
if (knownResults != null)
{
reportWriter.Write(";" + CalculateRelativeError(knownResults[problemId], bruteForceResult.Item1));
}
}
if (Options.CostToRatioHeuristics)
{
Tuple <int, long> heuristicsResult = costToRatioHeuristicsResults[problemId];
reportWriter.Write(";" + heuristicsResult.Item1 + ";" + heuristicsResult.Item2 / frequency);
if (knownResults != null)
{
reportWriter.Write(";" + CalculateRelativeError(knownResults[problemId], heuristicsResult.Item1));
}
}
if (Options.BranchAndBound)
{
Tuple <int, long> heuristicsResult = branchAndBoundResults[problemId];
reportWriter.Write(";" + heuristicsResult.Item1 + ";" + heuristicsResult.Item2 / frequency);
if (knownResults != null)
{
reportWriter.Write(";" + CalculateRelativeError(knownResults[problemId], heuristicsResult.Item1));
}
}
if (Options.DynamicByCost)
{
Tuple <int, long> heuristicsResult = dynamicByCostResults[problemId];
reportWriter.Write(";" + heuristicsResult.Item1 + ";" + heuristicsResult.Item2 / frequency);
if (knownResults != null)
{
reportWriter.Write(";" + CalculateRelativeError(knownResults[problemId], heuristicsResult.Item1));
}
}
if (Options.FPTAS)
{
Tuple <int, long> heuristicsResult = fptasResults[problemId];
reportWriter.Write(";" + heuristicsResult.Item1 + ";" + heuristicsResult.Item2 / frequency);
if (knownResults != null)
{
reportWriter.Write(";" + CalculateRelativeError(knownResults[problemId], heuristicsResult.Item1));
reportWriter.Write(";" + ((FPTASSolver)fptasSolver).GetMaximumError(problem));
}
}
if (Options.Genetics)
{
Tuple <int, long> heuristicsResult = geneticResults[problemId];
reportWriter.Write(";" + heuristicsResult.Item1 + ";" + heuristicsResult.Item2 / frequency);
if (knownResults != null)
{
reportWriter.Write(";" + CalculateRelativeError(knownResults[problemId], heuristicsResult.Item1));
}
}
reportWriter.WriteLine();
}
if (Options.Genetics)
{
decimal totalTime = 0;
decimal totalError = 0;
foreach (KnapsackProblemModel problem in knapsackProblemModels)
{
int problemId = problem.ProblemId;
Tuple <int, long> result = geneticResults[problemId];
totalTime += (result.Item2 / frequency);
totalError += CalculateRelativeError(knownResults[problemId], result.Item1);
}
decimal averageError = totalError / knapsackProblemModels.Count;
reportWriter.WriteLine("Aggregate results");
reportWriter.WriteLine("Aggregate time");
reportWriter.WriteLine(totalTime);
reportWriter.WriteLine("Average error");
reportWriter.WriteLine(averageError);
}
}
else
{
Environment.Exit(1);
}
Environment.Exit(0);
}
public int Solve(KnapsackProblemModel problem)
{
double BestSolution = 0;
Population population = new Population(
_populationSize,
new BinaryChromosome(problem.Items.Count),
new KnapsackFitnessFunction(
new Bag(problem.BagCapacity),
problem.Items.ToList()),
_selectionMethod)
{
MutationRate = _mutationRate, CrossoverRate = _crossoverRate, RandomSelectionPortion = _randomSelectionPortion, AutoShuffling = true
};
StreamWriter log = null;
if (_logging)
{
string path = "GeneticsLog_" + problem.ProblemId;
if (File.Exists(path))
{
log = File.AppendText(path);
}
else
{
log = File.CreateText(path);
}
log.WriteLine("Population size," + _populationSize);
log.WriteLine("Crossover rate," + _crossoverRate);
log.WriteLine("Mutation rate," + _mutationRate);
log.WriteLine("Random selection portion," + _randomSelectionPortion);
log.WriteLine("Selection method," + _selectionMethod);
log.WriteLine("Diversity check," + _diversityCheck);
log.WriteLine("Iteration,FitnessMax,FitnessAvg");
}
for (int i = 0; i < _iterationsCount; i++)
{
population.RunEpoch();
if (population.FitnessMax > BestSolution)
{
BestSolution = population.FitnessMax;
}
if (log != null)
{
log.WriteLine(i + "," + population.FitnessMax + "," + population.FitnessAvg);
}
if (_diversityCheck)
{
if ((population.FitnessMax - population.FitnessAvg) < (population.FitnessMax * 0.03))
{
IChromosome bestChromosome = population.BestChromosome;
population.Regenerate();
population.AddChromosome(bestChromosome);
}
}
}
if (log != null)
{
log.Close();
}
return(Convert.ToInt32(BestSolution));
}
