static void RunEditDistance(TestCaseOptions opt)
{
Console.Write("Run using defaults? (Y/N):");
var runDefaults = Console.ReadLine().Trim();
string a, b;
a = "editing";
b = "distance";
if (runDefaults.ToLower().Equals("n"))
{
Console.Write("\nEnter first string:");
a = Console.ReadLine();
Console.Write("\nEnter second string:");
b = Console.ReadLine();
}
var editDistResult = DynamicProgramming.EditDistance(a, b);
Console.WriteLine("Editing Distance of {0}, {1}: {2}", a, b, editDistResult[a.Length, b.Length]);
var sb = new StringBuilder();
var backtrackResult = DynamicProgramming.EditDistanceBacktrack(editDistResult, a, b);
foreach (var alignment in backtrackResult)
{
sb.AppendFormat("[{0}:{1}] ", alignment.Item1, alignment.Item2);
}
Console.WriteLine("Outputting Alignment {0}", sb.ToString());
}
public void NumberSolitaireTest()
{
var dp = new DynamicProgramming();
Assert.Equal(8, dp.NumberSolitaire(new int[] { 1, -2, 0, 9, -1, -2 }));
Assert.Equal(4, dp.NumberSolitaire(new int[] { -2, 5, 1 }));
}
public static void Test()
{
//BigRational test = new BigRational();
//test = 2;
//Debug.Log(test.ToString());
//Debug.Log(((Double)test).ToString());
//Debug.Log(((int)test).ToString());
BigRational result = CalculatePi_BBP_BigFraction();
Debug.Log(result.ToString());
Debug.Log(((float)result).ToString());
Debug.Log(((double)result).ToString());
Debug.Log(((decimal)result).ToString());
string piStr = result.ToDecimalString(1000);
Debug.Log(piStr);
string lcsPi = DynamicProgramming.LCS(piStr, PI);
Debug.Log(lcsPi.Length.ToString());
Debug.Log("阶乘" + CalculateFactorial(100).ToString());
Debug.Log("斐波那契" + CalculateFibonacci(100).ToString());
Debug.Log("pow(2,64)" + BigInteger.Pow(2, 64).ToString());
}
public void TestTripleStep()
{
// Arrange
int n = 5;
// Act
int result = DynamicProgramming.TripleStep(n);
int bottomUpResult = DynamicProgramming.TripleStepBottomUp(n);
// Assert
Assert.AreEqual(11, result);
Assert.AreEqual(11, bottomUpResult);
}
static void RunKnapsackWithoutRepetitions(TestCaseOptions opt)
{
Console.Write("Run using defaults? (Y/N):");
var runDefaults = Console.ReadLine().Trim();
Tuple <int, int>[] items;
int[] knapsackWeights;
if (runDefaults.ToLower().Equals("y") || runDefaults == string.Empty)
{
items = new Tuple <int, int>[] {
new Tuple <int, int>(10, 60),
new Tuple <int, int>(20, 100),
new Tuple <int, int>(30, 120),
};
knapsackWeights = new int[] { 10, 20, 30, 40, 50, 60 };
}
else
{
Console.Write("Enter num knapsack items:");
var numItems = Convert.ToInt32(Console.ReadLine().Trim());
items = new Tuple <int, int> [numItems];
for (var i = 0; i < numItems; i++)
{
Console.Write("\nEnter weight and value for item {0}:", i + 1);
var knapItem = ReadLineParseInts();
items[i] = new Tuple <int, int>(Convert.ToInt32(knapItem[0]), Convert.ToInt32(knapItem[1]));
}
Console.Write("\nEnter optimal knapsack weights to test:");
var weights = ReadLineParseInts();
knapsackWeights = new int[weights.Length];
for (var i = 0; i < weights.Length; i++)
{
knapsackWeights[i] = Convert.ToInt32(weights[i]);
}
}
foreach (var capacity in knapsackWeights)
{
var result = DynamicProgramming.KnapsackWithoutRepetitions(capacity, items);
Console.WriteLine("Knapsack without Repetitions, knapsack capacity {0}, max total value {1}", capacity, result[capacity, items.Length]);
var backtrack = DynamicProgramming.KnapsackWithoutRepetitionsBacktrack(capacity, items);
var output = Helper.Display(backtrack);
Console.WriteLine("{0}", output);
}
}
static void RunEditDistanceOnGeneSequence(TestCaseOptions opt)
{
Console.Write("Run using defaults? (Y/N):");
var runDefaults = Console.ReadLine().Trim();
int count = 10, length = 15;
if (runDefaults.ToLower().Equals("n"))
{
Console.Write("\nEnter sequence count and length:");
var inputs = ReadLineParseInts();
count = inputs[0];
length = inputs[1];
}
var sequencePairs = GenerateNucleotideSequencePairs(count, length);
foreach (var pair in sequencePairs)
{
var editDistResult = DynamicProgramming.EditDistance(pair.Item1, pair.Item2);
Console.WriteLine("Editing Distance of {0}, {1}: {2}", pair.Item1, pair.Item2, editDistResult[pair.Item1.Length, pair.Item2.Length]);
}
}
static void RunLongestCommonSubsequence(TestCaseOptions opt)
{
Console.Write("Run using defaults? (Y/N):");
var runDefaults = Console.ReadLine().Trim();
string a, b;
a = "editing";
b = "distance";
if (runDefaults.ToLower().Equals("n"))
{
Console.Write("\nEnter first string:");
a = Console.ReadLine();
Console.Write("\nEnter second string:");
b = Console.ReadLine();
}
var result = DynamicProgramming.LongestCommonSubsequence(a, b);
Console.WriteLine("LCS for input sequences {0}, {1}: {2}", a, b, result[a.Length, b.Length]);
var backtrackResult = DynamicProgramming.LCSBacktrack(result, a, b);
Console.WriteLine("Outputting Alignment {0}", new string(backtrackResult));
}
public DPSearchSpectrumCID(double tol = 20, double min = 400, double size = 0.01, int distance = 3)
{
parameter = new DPSpectrumCIDParameter(tol, min, size, distance);
dp = new DynamicProgramming();
}
public DPSearchSpectrumCID(DPSpectrumCIDParameter parameter)
{
this.parameter = parameter;
dp = new DynamicProgramming();
}
static void Test_KnapsackProblem()
{
DynamicProgramming.KnapsackProblem(new int[] { 1, 3, 4, 5 }, new int[] { 1, 4, 5, 7 }, 7);
Console.ReadLine();
}
public void Test_LongestPalindromeSubseq()
{
Assert.AreEqual(4, DynamicProgramming.LongestPalindromeSubseq("bbbab"));
}
public void Test_SubSetSum()
{
var ret = DynamicProgramming.subsetSum(new int[] { 1, 5, 5, 11 }, 11);
ret = DynamicProgramming.subsetSum(new int[] { 4, 3, 2, 3, 5, 2, 1 }, 5);
}
public void Test_CanPartition()
{
Assert.AreEqual(true, DynamicProgramming.CanPartition(new int[] { 1, 5, 11, 5 }));
}
public void Test_CoinChange()
{
Assert.AreEqual(3, DynamicProgramming.CoinChange(new int[] { 2, 3, 5 }, 11));
Assert.AreEqual(3, DynamicProgramming.CoinChange(new int[] { 2 }, 3));
Assert.AreEqual(3, DynamicProgramming.CoinChange(new int[] { 1 }, 0));
}
public void Test_NumTrees()
{
Assert.AreEqual(5, DynamicProgramming.NumTrees(3));
}
// Measure algorithms time
private static TestResult RunAlgorithms(Dataset dataSet, int measurementCount)
{
Console.WriteLine("{0}: starting calculating dateset {1}", DateTime.Now, dataSet.GetFilePath());
var csvBuilder = new StringBuilder();
csvBuilder.AppendLine(TestResultHelper.GetInstanceResultHeader());
var stopwatch = new Stopwatch();
double BFTotal = 0;
double BandBTotal = 0;
double dpTotal = 0;
double reduxTotal = 0;
double reduxErrSum = 0;
double reduxMaxErr = 0;
double greedyTotal = 0;
double greedyErrSum = 0;
double greedyMaxErr = 0;
double ftpasTotal = 0;
for (int i = 1; i <= dataSet.LastInstanceId; i++)
{
Console.WriteLine($"{DateTime.Now}::{dataSet.Name}::{dataSet.InstanceItemsCount}::{i}");
// Load instance and solution
var instance = InstanceLoader.LoadInstanceAsync(dataSet, i);
if (instance == null)
{
continue;
}
int optimalResult = InstanceLoader.LoadSolution(dataSet, i);
double bruteForceTimeAvg = 0;
double branchAndBoundTimeAvg = 0;
double dynamicProgrammingAvg = 0;
double greedyAvg = 0;
double reduxAvg = 0;
int[] greedyHeuristicResult = null;
int[] reduxHeuristicResult = null;
for (int j = 0; j < measurementCount; j++)
{
stopwatch.Reset();
// Start Brute Force
stopwatch.Start();
var bruteForceResult = BruteForce.Solve(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, instance.MinPrice, new int[instance.N + 1], new int[instance.N + 1]);
stopwatch.Stop();
CheckResult(instance, bruteForceResult[instance.N], optimalResult, dataSet.Name, nameof(BruteForce));
bruteForceTimeAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Branch and Bound
stopwatch.Start();
var branchAndBoundResult = BranchAndBound.Solve(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, new int[instance.N + 1], new int[instance.N + 1]);
//BranchAndBound.Decide(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, 324);
stopwatch.Stop();
CheckResult(instance, branchAndBoundResult[instance.N], optimalResult, dataSet.Name, nameof(BranchAndBound));
branchAndBoundTimeAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Dynamic programming
stopwatch.Start();
var dynamicProgrammingResult = DynamicProgramming.Solve(instance.Items, instance.MaxWeight);
stopwatch.Stop();
CheckResult(instance, dynamicProgrammingResult[instance.N], optimalResult, dataSet.Name, nameof(DynamicProgramming));
dynamicProgrammingAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Greedy heuristic
stopwatch.Start();
greedyHeuristicResult = GreedyHeuristic.Solve(instance.Items.ToList(), instance.MaxWeight);
stopwatch.Stop();
//CheckResult(instance, greedyHeuristicResult[instance.N], optimalPrice, dataSet.Name, nameof(GreedyHeuristic));
greedyAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Redux heuristic
stopwatch.Start();
reduxHeuristicResult = ReduxHeuristic.Solve(instance.Items.ToList(), instance.MaxWeight);
stopwatch.Stop();
reduxAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
}
BFTotal += Avg(bruteForceTimeAvg, measurementCount);
BandBTotal += Avg(branchAndBoundTimeAvg, measurementCount);
dpTotal += Avg(dynamicProgrammingAvg, measurementCount);
greedyTotal += Avg(greedyAvg, measurementCount);
reduxTotal += Avg(reduxAvg, measurementCount);
csvBuilder.AppendLine(TestResultHelper.FormatInstanceResultRow(
instance.Id,
instance.N,
Avg(bruteForceTimeAvg, measurementCount),
Avg(branchAndBoundTimeAvg, measurementCount),
Avg(dynamicProgrammingAvg, measurementCount),
Avg(greedyAvg, measurementCount),
Avg(reduxAvg, measurementCount),
0
));
}
Console.WriteLine("{0}: calculating dataset {1} ended", DateTime.Now, dataSet.GetFilePath());
return(new TestResult
{
InstanceSize = dataSet.InstanceItemsCount,
InstancesResults = csvBuilder.ToString(),
BFTime = Avg(BFTotal, dataSet.InstancesCount),
BandBTime = Avg(BandBTotal, dataSet.InstancesCount),
GreedyHeuristicTime = Avg(greedyTotal, dataSet.InstancesCount),
ReduxHeuristicTime = Avg(reduxTotal, dataSet.InstancesCount),
DPTime = Avg(dpTotal, dataSet.InstancesCount),
FTPASTime = Avg(ftpasTotal, dataSet.InstancesCount),
GreedyRelErr = Avg(greedyErrSum, dataSet.InstancesCount),
GreedyMaxErr = greedyMaxErr,
ReduxRelErr = Avg(reduxErrSum, dataSet.InstancesCount),
ReduxMaxErr = reduxMaxErr
});
}
