Esempio n. 1
0
        private EditPath Clone()
        {
            var editPathClone = new EditPath(Graph, targetGraph);

            editPathClone.EdgeAdditionsPending = new List <GraphEdge>(EdgeAdditionsPending);
            editPathClone.Path                     = new List <CalculatedOperation>(Path);
            editPathClone.cumelativeCost           = cumelativeCost;
            editPathClone.SourceNodesLeftToResolve = new List <InstructionNode>(SourceNodesLeftToResolve);
            editPathClone.TargetNodesLeftToResolve = new List <InstructionNode>(TargetNodesLeftToResolve);
            return(editPathClone);
        }
Esempio n. 2
0
        public static EditPath GetEditDistance(List <InstructionNode> sourceGraph, List <InstructionNode> targetGraph)
        {
http:       //www.springer.com/cda/content/document/cda_downloaddocument/9783319272511-c2.pdf?SGWID=0-0-45-1545097-p177820399
            //step 1 = take all the first graph nodes
            //step 2 = concider for each one, replacing with each one of the second graph
            //step 3 = concider for each one, deleting
            //continue until no more nodes left of the first graph

            // the code that you want to measure comes here

            int index = 0;
            var pathsToConcider = new DuplicateKeySortedDictionary();

            pathsToConcider.Add(new EditPath(sourceGraph, targetGraph));
            var      cheapestPaths = pathsToConcider.First().Value;
            EditPath cheapestPath  = cheapestPaths[0];

            while (true)
            {
                if (cheapestPath.SourceNodesLeftToResolve.Count != 0)
                {
                    List <CalculatedOperation> possibleOperations = GetPossibleSubsAndDelete(cheapestPath);
                    var tempAddedPaths = new ConcurrentBag <EditPath>();
                    Parallel.ForEach(possibleOperations, (possibleOperation) =>
                    {
                        tempAddedPaths.Add(cheapestPath.CloneWithEditOperation(possibleOperation));
                    });
                    foreach (var pathToConcider in tempAddedPaths)
                    {
                        pathsToConcider.Add(pathToConcider);
                    }
                }
                else
                {
                    foreach (var nodeToAdd in cheapestPath.TargetNodesLeftToResolve)
                    {
                        CalculatedOperation nodeAddition = new NodeAddition(cheapestPath.Graph, nodeToAdd, cheapestPath.EdgeAdditionsPending).GetCalculated();
                        EditPath            additionPath = cheapestPath.CloneWithEditOperation(nodeAddition);
                        pathsToConcider.Add(additionPath);
                    }
                }
                var oldCheapestPath = cheapestPath;
                pathsToConcider.Remove(cheapestPath);
                cheapestPath = pathsToConcider.First().Value[0];
                if (cheapestPath.HeuristicCost == 0)
                {
                    return(cheapestPath);
                }
            }
        }
Esempio n. 3
0
        public EditPath CloneWithEditOperation(CalculatedOperation calculatedOperation)
        {
            EditPath pathClone = Clone();

            pathClone.Path.Add(calculatedOperation);
            pathClone.cumelativeCost += calculatedOperation.Cost;
            pathClone.LatestOperation = calculatedOperation;
            foreach (var sourceNodeToRemove in calculatedOperation.DeletedNodes)
            {
                pathClone.SourceNodesLeftToResolve.Remove(sourceNodeToRemove);
            }
            foreach (var targetNodeToRemove in calculatedOperation.AddedNodes)
            {
                pathClone.TargetNodesLeftToResolve.Remove(targetNodeToRemove);
            }
            pathClone.HeuristicCost = pathClone.TargetNodesLeftToResolve.Count + pathClone.SourceNodesLeftToResolve.Count;
            pathClone.CumelativeCostPlusHeuristic = pathClone.cumelativeCost + pathClone.HeuristicCost;
            return(pathClone);
        }
Esempio n. 4
0
        private static List <CalculatedOperation> GetPossibleSubsAndDelete(EditPath currentPath)
        {
            var calculatedOperations = new ConcurrentBag <CalculatedOperation>();

            Parallel.ForEach(currentPath.SourceNodesLeftToResolve, (sourceNode) =>
            {
                var codeGroup = codeGroups.FirstOrDefault(x => x.Contains(sourceNode.Instruction.OpCode.Code));
                if (codeGroup == null)
                {
                    codeGroup = new Code[] { sourceNode.Instruction.OpCode.Code };
                }
                var possibleSubs = currentPath.TargetNodesLeftToResolve.Where(x => codeGroup.Contains(x.Instruction.OpCode.Code));
                Parallel.ForEach(currentPath.TargetNodesLeftToResolve, (targetNode) =>
                {
                    var nodeSubstitution = new NodeSubstitution(currentPath.Graph, currentPath.EdgeAdditionsPending, sourceNode, targetNode);
                    calculatedOperations.Add(nodeSubstitution.GetCalculated());
                });
                var nodeDeletion = new NodeDeletion(currentPath.Graph, sourceNode);
                calculatedOperations.Add(nodeDeletion.GetCalculated());
            });
            return(calculatedOperations.ToList());
        }