private void btnGraph_Click(object sender, EventArgs e) { double cAmount = double.Parse(txtChangeAmount.Text); double maxPrice = double.Parse(txtMaxPrice.Text); double minPrice = double.Parse(txtMinPrice.Text); if (chbIncludeExtra.Checked && !ExtraFunctions.ValidateExtraConfiguration(txtPeriod.Text, tbExtraPeriod.Text, cbPeriodType.SelectedIndex, cbExtraPeriodType.SelectedIndex)) { showError(Constancts.ErrorMessagePeriodType); } double basePrice = double.Parse(txtBasePrice.Text); int period = int.Parse(txtPeriod.Text); int periodType = cbPeriodType.SelectedIndex; double newPrice = basePrice; SetImport2FirstPeriods(period, basePrice); for (int i = period; i < _importDateData.Count; i++) { newPrice = AlgorithmFunctions.GetNewPrice(newPrice, period, periodType, _exportDateData, _exportSalesData, cAmount, maxPrice, minPrice); _exportPriceData.Add(newPrice); _exportSalesData.Add(AlgorithmFunctions.CalculateSales(newPrice, _importSalesData.ToArray()[i], double.Parse(txtBasePrice.Text))); } DateTime[] x = _importDateData.ToArray(); int[] y = _importSalesData.ToArray(); int[] y2 = _exportSalesData.ToArray(); Grahps grahps = new Grahps(Constancts.CompareTitule, Constancts.Serie1, x, y, Constancts.Serie2, y2); grahps.ShowGrahpVaues(); }
public void XORFunction() { Assert.IsTrue(AlgorithmFunctions.XOR('1', '1') == '0'); Assert.IsTrue(AlgorithmFunctions.XOR('1', '0') == '1'); Assert.IsTrue(AlgorithmFunctions.XOR('0', '1') == '1'); Assert.IsTrue(AlgorithmFunctions.XOR('0', '0') == '0'); }
public void KeyTransformantion() { string key = "10111110101011100001110001001110000010000100100000100011"; var transformedKey = AlgorithmFunctions.KeyTransformation(key, 0, EnumProcessType.ENCRYPTION); Assert.IsTrue(transformedKey.Length == 48); }
public async Task <IActionResult> Create([Bind("AnalysisName,UserIsNetworkSeed,UserGivenNetworkGeneration,UserGivenNodes,UserGivenTarget,UserGivenDrugTarget,AlgorithmType,GeneticRandomSeed,GeneticMaxIteration,GeneticMaxIterationNoImprovement,GeneticMaxPathLength,GeneticPopulationSize,GeneticElementsRandom,GeneticPercentageRandom,GeneticPercentageElite,GeneticProbabilityMutation,GreedyRandomSeed,GreedyMaxIteration,GreedyMaxIterationNoImprovement,GreedyMaxPathLength,GreedyRepeats,GreedyHeuristics")] AnalysisModel analysisModel) { ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User); analysisModel.User = user; // If the model is valid and the user is logged in. if (ModelState.IsValid && user != null) { // If the network is generated successfully. if (AlgorithmFunctions.GenerateNetwork(analysisModel)) { // Save the new analysis to the database. _context.Add(analysisModel); await _context.SaveChangesAsync(); // Calling on a Hangfire background task the analysis run. var analysisRun = new AnalysisRun(_context); BackgroundJob.Enqueue(() => analysisRun.RunAnalysis(analysisModel.AnalysisId)); // This also seems to be working. The only problem is that it's not implmeneted on a background task. // await AlgorithmFunctions.RunAnalysis(_context, analysisModel); // Return to Dashboard. return(RedirectToAction(nameof(Index))); } else { return(View(analysisModel)); } } return(View(analysisModel)); }
public void CompressionPermutation() { Assert.IsTrue(Data.CompressionPermutationTable.Length == 48); string data = "ENSAR DUMAN"; //56 to 48 var res = AlgorithmFunctions.CompressionPermutation(data); }
public void CircularLeftShift() { string data = "ENSAR DUMAN"; var res = AlgorithmFunctions.CircularLeftShift(data, 0, EnumProcessType.ENCRYPTION); res = AlgorithmFunctions.CircularLeftShift(res, 0, EnumProcessType.DECRYPTION); Assert.IsTrue(res == data); }
public void ExpensionPermutation() { Assert.IsTrue(Data.ExpansionPermutationTable.Length == 48); string data = "ENSAR DUMAN"; //32 to 48 var res2 = AlgorithmFunctions.ExpentsonPermutation(data); }
public void FinalPermutation() { for (int i = 1; i <= 64; i++) { Assert.IsTrue(Data.InitialPermutationTable.Contains(i)); } var data = "0011111111100111000100111101100000101000010110001111111100101100"; var output = AlgorithmFunctions.FinalPermutation(data); Assert.IsTrue(output == "0101110001011100010110101110101101101101110110100011100100011001"); }
private void btnSingleValue_Click(object sender, EventArgs e) { double basePrice = double.Parse(txtBasePrice.Text); int period = int.Parse(txtPeriod.Text); int periodType = cbPeriodType.SelectedIndex; double cAmount = double.Parse(txtChangeAmount.Text); double maxPrice = double.Parse(txtMaxPrice.Text); double minPrice = double.Parse(txtMinPrice.Text); SetImport2FirstPeriods(period, basePrice); txtSingleValue.Text = AlgorithmFunctions.GetNewPrice(basePrice, period, periodType, _exportDateData, _exportSalesData, cAmount, maxPrice, minPrice).ToString(); }
/// <summary> /// The initial testing program of the greedy algorithm. /// </summary> public static void InitialProgram() { var randomSeed = new Random().Next(); var separators = new List <String>() { ";", "\t", "\n", "\r" }; var rand = new Random(randomSeed); var graphType = "BreastDEF"; var graphText = System.IO.File.ReadAllText($@"C:\Users\vpopescu\source\repos\NetControl\NetControl\Networks\{graphType}Graph.txt"); var targetText = System.IO.File.ReadAllText($@"C:\Users\vpopescu\source\repos\NetControl\NetControl\Networks\{graphType}Target.txt"); var drugTargetText = System.IO.File.ReadAllText($@"C:\Users\vpopescu\source\repos\NetControl\NetControl\Networks\DrugTarget.txt"); var greedyRepeats = 2; var greedyHeuristic = "A;B;C;D;E;F;G;Z"; var greedyMaxPathLength = 5; var greedyMaxIterations = 1000; var greedyMaxIterationsNoImprovement = 100; var nodes = AlgorithmFunctions.GetNodes(graphText, separators); var edges = AlgorithmFunctions.GetEdges(graphText, separators); var targets = AlgorithmFunctions.GetTargetNodes(targetText, nodes, separators); var drugTargets = AlgorithmFunctions.GetTargetNodes(drugTargetText, nodes, separators); var fullSeparator = ";"; var halfSeparator = ","; // Get the heuristic list from the string. var heuristics = AlgorithmGreedyFunctions.GetHeuristic(greedyHeuristic, fullSeparator, halfSeparator); // Get all heuristics. var allHeuristics = new List <string>(); foreach (var item in heuristics) { foreach (var h in item) { allHeuristics.Add(h); } } Console.WriteLine($"{nodes.Count} nodes, {edges.Count} edges, {targets.Count} targets, {drugTargets.Count} drug targets."); heuristics.ForEach((item) => { item.ForEach((h) => Console.Write($"{h} ")); Console.Write("; "); }); Console.WriteLine(); // Set up for the initial iteration. var currentIteration = 0; var currentIterationNoImprovement = 0; var bestResult = targets.Count; // Run for as long as we haven't reached the final iteration or the final iteration without improvement. while (currentIteration < greedyMaxIterations && currentIterationNoImprovement < greedyMaxIterationsNoImprovement) { // Display the current iteration. // Console.WriteLine($"Now at iteration {currentIteration} / {greedyMaxIterations}, {currentIterationNoImprovement} / {greedyMaxIterationsNoImprovement}"); // Set up the control path to start from the target nodes. var controlPath = new Dictionary <String, List <String> >(); targets.ForEach((node) => controlPath[node] = new List <String>() { node }); var currentRepeat = 0; while (currentRepeat < greedyRepeats) { var currentTargets = new List <String>(targets); var currentPathLength = 0; // If it is the first check of the current iteration, we have no kept nodes, so the current targets are simply the targets. // The optimization part for the "repeats" starts here. var keptNodes = AlgorithmGreedyFunctions.GetKeptTargetNodes(controlPath); controlPath = AlgorithmGreedyFunctions.ResetControlPath(keptNodes, controlPath); currentTargets = currentTargets.Except(keptNodes).ToList(); // Run until there are no current targets or we reached the maximum path length. while (currentTargets.Any() && currentPathLength < greedyMaxPathLength) { //var (matchedEdges, unmatched) = ComputeMaximalMatching(nodes, edges, heuristics, controlPath, currentTargets, rand, drugTargets); var unmatched = new List <string>(); unmatched.AddRange(currentTargets); var free = new List <string>(); free.AddRange(nodes); var matchedEdges = new List <(string, string)>(); // If it is the first check of the current iteration, we have no kept nodes, so the left nodes and edges remain unchanged. // Otherwise, we remove from the left nodes the corresponding nodes in the current step in the control paths for the kept nodes. // The optimization part for the "repeat" begins here. foreach (var item in keptNodes) { if (currentPathLength + 1 < controlPath[item].Count) { var leftNode = controlPath[item][currentPathLength + 1]; free.Remove(leftNode); } } foreach (var heuristic in heuristics) { var matchings = new List <(string, string)>(); var left = new List <string>(); left.AddRange(free); var right = new List <string>(); right.AddRange(unmatched); var currentEdges = new List <(string, string)>(); currentEdges = GetSingleHeuristicEdges(left, right, edges, heuristic, controlPath, drugTargets); var mEdges = GetMaximumMatching(left, right, currentEdges, rand); foreach (var mEdge in mEdges) { matchedEdges.Add(mEdge); free.Remove(mEdge.Item1); unmatched.Remove(mEdge.Item2); } } currentTargets = AlgorithmGreedyFunctions.GetMatchedNodes(matchedEdges); // And update the control path. controlPath = AlgorithmGreedyFunctions.UpdateControlPath(matchedEdges, controlPath); currentPathLength++; } currentRepeat++; } // Display the control path for the current iteration. //foreach (var item in controlPath) //{ // Console.Write($"{item.Key}:\t"); // foreach (var node in item.Value) // { // Console.Write($"{node}\t"); // } // Console.WriteLine(); //} //Console.WriteLine("----"); // The optimization part for the "cut to driven" parameter begins here. var stop = false; while (!stop) { stop = true; foreach (var item1 in controlPath) { var controllingNode = item1.Value.Last(); foreach (var item2 in controlPath) { var firstIndex = item2.Value.IndexOf(controllingNode); if (firstIndex != -1 && firstIndex != item2.Value.Count - 1) { item2.Value.RemoveRange(firstIndex + 1, item2.Value.Count - firstIndex - 1); stop = false; } } } } // We compute the result. var controllingNodes = AlgorithmGreedyFunctions.GetControllingNodes(controlPath).Keys.ToList(); var result = controllingNodes.Count; // If the current solution is better than the previously obtained best solution. if (result < bestResult) { bestResult = result; Console.WriteLine($"{result} nodes in best solution so far, out of which {controllingNodes.Intersect(drugTargets).Count()} drug targets."); controllingNodes.ForEach((node) => Console.Write($"{node} ")); Console.WriteLine(); currentIterationNoImprovement = 0; } else { currentIterationNoImprovement++; } currentIteration++; } }
/// <summary> /// Runs the genetic algorithm on the given analysis. /// </summary> /// <param name="analysisModel">The analysis upon which to run the algorithm.</param> /// <param name="separators">The separators which are used to split the entries in the database strings.</param> /// <returns></returns> private async Task RunGeneticAlgorithm(AnalysisModel analysisModel, List <String> separators) { // Get the initial list of nodes and edges from the generated network. var oldNodes = AlgorithmFunctions.GetNodes(analysisModel.NetworkEdges, separators); var oldEdges = AlgorithmFunctions.GetEdges(analysisModel.NetworkEdges, separators); var oldTargets = AlgorithmFunctions.GetTargetNodes(analysisModel.NetworkTargets, oldNodes, separators); var oldTargetIndices = AlgorithmGeneticFunctions.GetTargetIndices(oldNodes, oldTargets); var oldA = AlgorithmGeneticFunctions.GetAdjacencyMatrix(oldNodes, oldEdges); var oldPowersA = AlgorithmGeneticFunctions.GetAdjacencyMatrixPowers(oldA, analysisModel.GeneticMaxPathLength.Value); var oldList = AlgorithmGeneticFunctions.GetList(oldPowersA, oldTargetIndices); // Get the trimmed list of nodes and edges. var nodes = AlgorithmGeneticFunctions.GetNewNodes(oldNodes, oldList); var edges = AlgorithmGeneticFunctions.GetNewEdges(oldEdges, nodes); var singleNodes = AlgorithmGeneticFunctions.GetSingleTargets(nodes, oldTargets); var A = AlgorithmGeneticFunctions.GetAdjacencyMatrix(nodes, edges); var targets = AlgorithmGeneticFunctions.GetNewTargets(nodes, oldTargets); var drugTargets = analysisModel.NetworkDrugTargetCount.Value != 0 ? AlgorithmFunctions.GetTargetNodes(analysisModel.NetworkDrugTargets, nodes, separators) : null; var targetIndices = AlgorithmGeneticFunctions.GetTargetIndices(nodes, targets); var C = AlgorithmGeneticFunctions.GetTargetMatrix(nodes, targetIndices); var powersA = AlgorithmGeneticFunctions.GetAdjacencyMatrixPowers(A, analysisModel.GeneticMaxPathLength.Value); var powers = AlgorithmGeneticFunctions.GetTargetMatrixPowers(C, powersA); var list = AlgorithmGeneticFunctions.GetList(powersA, targetIndices); // Initialization of the first population. var rand = new Random(analysisModel.GeneticRandomSeed.Value); var bestFitness = 0.0; var p = new Population(analysisModel.GeneticPopulationSize.Value); p.Initialize(powers, list, analysisModel.GeneticElementsRandom.Value, rand); // Running for the given number of iterations. while (analysisModel.AlgorithmCurrentIteration < analysisModel.GeneticMaxIteration && analysisModel.AlgorithmCurrentIterationNoImprovement < analysisModel.GeneticMaxIterationNoImprovement && !analysisModel.ScheduledToStop.Value) { // Move on to the next population. p = p.nextPopulation(analysisModel.GeneticPercentageElite.Value, analysisModel.GeneticPercentageRandom.Value, analysisModel.GeneticProbabilityMutation.Value, powers, list, analysisModel.GeneticElementsRandom.Value, rand); // Get the best fitness of the current population. var fitness = p.getBestFitness(); // If the fitness is better than the current best one. if (bestFitness <= fitness) { if (bestFitness < fitness) { // Update the current best fitness. bestFitness = fitness; analysisModel.AlgorithmCurrentIterationNoImprovement = -1; } // Get the best results. var bestChromosomes = p.GetBestChromosomes(); var result = ""; foreach (var chromosome in bestChromosomes) { foreach (var gene in chromosome.Genes.Distinct()) { result += nodes[gene] + ";"; } result += "\n"; } analysisModel.NetworkBestResultCount = bestChromosomes.First().Genes.Distinct().Count(); analysisModel.NetworkBestResultNodes = result; analysisModel.AlgorithmCurrentIterationNoImprovement++; } else { analysisModel.AlgorithmCurrentIterationNoImprovement++; } analysisModel.AlgorithmCurrentIteration++; analysisModel.Status = $"Analysis ongoing ({analysisModel.AlgorithmCurrentIteration} / {analysisModel.GeneticMaxIteration}, " + $"{analysisModel.AlgorithmCurrentIterationNoImprovement} / {analysisModel.GeneticMaxIterationNoImprovement})."; await _context.SaveChangesAsync(); } analysisModel.Status = "Completed"; analysisModel.EndTime = DateTime.Now; await _context.SaveChangesAsync(); }
/// <summary> /// Runs the greedy algorithm on the given analysis. /// </summary> /// <param name="analysisModel">The analysis upon which to run the algorithm.</param> /// <param name="separators">The separators which are used to split the entries in the database strings.</param> /// <returns></returns> private async Task RunGreedyAlgorithm(AnalysisModel analysisModel, List <String> separators) { // Get the list of nodes and edges from the generated network. var nodes = AlgorithmFunctions.GetNodes(analysisModel.NetworkEdges, separators); var edges = AlgorithmFunctions.GetEdges(analysisModel.NetworkEdges, separators); var targets = AlgorithmFunctions.GetTargetNodes(analysisModel.NetworkTargets, nodes, separators); var drugTargets = analysisModel.NetworkDrugTargetCount.Value != 0 ? AlgorithmFunctions.GetTargetNodes(analysisModel.NetworkDrugTargets, nodes, separators) : null; // Get the heuristic list from the string. var fullSeparator = ";"; var halfSeparator = ","; var heuristics = AlgorithmGreedyFunctions.GetHeuristic(analysisModel.GreedyHeuristics, fullSeparator, halfSeparator); // Get all heuristics. var allHeuristics = new List <string>(); foreach (var item in heuristics) { foreach (var h in item) { allHeuristics.Add(h); } } // Set up for the first iteration. var bestResult = targets.Count; var rand = new Random(analysisModel.GreedyRandomSeed.Value); // Run for as long as we haven't reached the final iteration or the final iteration without improvement. while (analysisModel.AlgorithmCurrentIteration < analysisModel.GreedyMaxIteration && analysisModel.AlgorithmCurrentIterationNoImprovement < analysisModel.GreedyMaxIterationNoImprovement && !analysisModel.ScheduledToStop.Value) { // Set up the control path to start from the target nodes. var controlPath = new Dictionary <String, List <String> >(); targets.ForEach((node) => controlPath[node] = new List <String>() { node }); var currentRepeat = 0; while (currentRepeat < analysisModel.GreedyRepeats) { var currentTargets = new List <String>(targets); var currentPathLength = 0; // If it is the first check of the current iteration, we have no kept nodes, so the current targets are simply the targets. // The optimization part for the "repeats" starts here. var keptNodes = AlgorithmGreedyFunctions.GetKeptTargetNodes(controlPath); controlPath = AlgorithmGreedyFunctions.ResetControlPath(keptNodes, controlPath); currentTargets = currentTargets.Except(keptNodes).ToList(); while (currentTargets.Any() && currentPathLength + 1 < analysisModel.GreedyMaxPathLength) { // Compute the current edges ending in the current targets. var heuristicEdges = AlgorithmGreedyFunctions.GetHeuristicEdges(currentTargets, edges, heuristics, allHeuristics, controlPath, drugTargets); // Start building the bipartite graph for the current step. var leftNodes = heuristicEdges.Select((edge) => edge.Item1).Distinct().ToList(); var rightNodes = new List <String>(currentTargets); var matchingEdges = new List <(String, String)>(heuristicEdges); // If it is the first check of the current iteration, we have no kept nodes, so the left nodes and edges remain unchanged. // Otherwise, we remove from the left nodes the corresponding nodes in the current step in the control paths for the kept nodes. // The optimization part for the "repeat" begins here. foreach (var item in keptNodes) { if (currentPathLength + 1 < controlPath[item].Count) { var leftNode = controlPath[item][currentPathLength + 1]; leftNodes.Remove(leftNode); matchingEdges.RemoveAll((edge) => edge.Item1 == leftNode); } } // Compute the maximum matching and the matched left nodes, which will become the new current targets. var matchedEdges = AlgorithmGreedyFunctions.GetMaximumMatching(leftNodes, rightNodes, matchingEdges, rand); var unmatchedRightNodes = AlgorithmGreedyFunctions.GetUnmatchedNodes(currentTargets, matchedEdges); currentTargets = AlgorithmGreedyFunctions.GetMatchedNodes(matchedEdges); // And update the control path. controlPath = AlgorithmGreedyFunctions.UpdateControlPath(matchedEdges, controlPath); currentPathLength++; } currentRepeat++; } // The optimization part for the "cut to driven" parameter begins here. var stop = false; while (!stop) { stop = true; foreach (var item1 in controlPath) { var controllingNode = item1.Value.Last(); foreach (var item2 in controlPath) { var firstIndex = item2.Value.IndexOf(controllingNode); if (firstIndex != -1 && firstIndex != item2.Value.Count - 1) { item2.Value.RemoveRange(firstIndex, item2.Value.Count - 1 - firstIndex); stop = false; } } } } // We compute the result. var controllingNodes = AlgorithmGreedyFunctions.GetControllingNodes(controlPath).Keys.ToList(); var result = controllingNodes.Count; // If the current solution is better than the previously obtained best solution. if (result < bestResult) { bestResult = result; var resultNodes = ""; analysisModel.AlgorithmCurrentIterationNoImprovement = 0; analysisModel.NetworkBestResultCount = result; controllingNodes.ForEach((node) => resultNodes += nodes + ";"); analysisModel.NetworkBestResultNodes = resultNodes; } else { analysisModel.AlgorithmCurrentIterationNoImprovement++; } analysisModel.AlgorithmCurrentIteration++; analysisModel.Status = $"Analysis ongoing ({analysisModel.AlgorithmCurrentIteration} / {analysisModel.GreedyMaxIteration}, " + $"{analysisModel.AlgorithmCurrentIterationNoImprovement} / {analysisModel.GreedyMaxIterationNoImprovement})."; await _context.SaveChangesAsync(); } analysisModel.Status = "Completed"; analysisModel.EndTime = DateTime.Now; await _context.SaveChangesAsync(); }