Beispiel #1
0
        public static void TestCaseBook()
        {
            // 1. Create a graph
            CGraph mgraph = CGraph.CreateGraph();

            CGraphNode u = mgraph.CreateGraphNode <CGraphNode>("u");
            CGraphNode v = mgraph.CreateGraphNode <CGraphNode>("v");
            CGraphNode w = mgraph.CreateGraphNode <CGraphNode>("w");
            CGraphNode x = mgraph.CreateGraphNode <CGraphNode>("x");
            CGraphNode y = mgraph.CreateGraphNode <CGraphNode>("y");
            CGraphNode z = mgraph.CreateGraphNode <CGraphNode>("z");

            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(u, v, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(u, x, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(x, v, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(v, y, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(y, x, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, y, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, z, GraphType.GT_DIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(z, z, GraphType.GT_DIRECTED);

            DepthFirstSearch dfs = new DepthFirstSearch(mgraph);

            dfs.Run();

            DepthFirstSearchQueryInfo info = new DepthFirstSearchQueryInfo(mgraph, dfs);
            CIt_GraphNodes            it   = new CIt_GraphNodes(mgraph);

            for (it.Begin(); !it.End(); it.Next())
            {
                Console.WriteLine("Node {0}: arrival ({1}) - departure ({2})",
                                  it.M_CurrentItem.M_Label, info.Arrival(it.M_CurrentItem), info.Departure(it.M_CurrentItem));
            }
        }
Beispiel #2
0
        public CGraphNode CreateGraphNode(List <CGraphNode> nodeSet)
        {
            // Every original graph node must participate in only one
            // condensed graph node
            foreach (CGraphNode node in nodeSet)
            {
                if (m_Mappings.IsOriginalNodeContained(node))
                {
                    throw new Exception("Every original graph node must participate in only one condensed graph node");
                }
            }
            CGraphNode newnode = CreateGraphNode();

            m_Mappings.SetDerivedToOriginalNodeMappings(newnode, nodeSet);
            //m_condensedNodeMappings[newnode] = nodeSet;
            foreach (CGraphNode node in nodeSet)
            {
                if (m_Mappings.IsOriginalNodeContained(node))
                {
                    m_Mappings.SetOriginalToDerivedNode(node, newnode);
                }
                else
                {
                    throw new Exception("Node participates in more than 1 condensed nodes");
                }
            }
            return(newnode);
        }
Beispiel #3
0
        public override FA VisitRegexpbasicSet(CASTElement currentNode)
        {
            CRegexpbasicSet  setNode = currentNode as CRegexpbasicSet;
            FAGraphQueryInfo FAInfo;

            //Create FA
            m_NFA  = new FA();
            FAInfo = new FAGraphQueryInfo(m_NFA, FA.m_FAINFOKEY);
            CGraphNode init  = m_NFA.CreateGraphNode <CGraphNode>();
            CGraphNode final = m_NFA.CreateGraphNode <CGraphNode>();

            m_NFA.M_Initial = init;
            m_NFA.SetFinalState(final);
            m_NFA.M_Alphabet.AddSet(setNode.MSet);

            CGraphEdge newEdge = m_NFA.AddGraphEdge <CGraphEdge, CGraphNode>(init, final, GraphType.GT_DIRECTED);

            FAInfo.Info(newEdge).M_TransitionCharSet = setNode.MSet;
            //4.Pass FA to the predecessor

            m_NFA.PrefixGraphElementLabels(m_currentRegularExpression.M_StatementID, GraphElementType.ET_NODE);

            m_ReportingServices.ExctractThompsonStep(m_NFA, @"../Debug/BasicSet_" + setNode.MSet.ToString() + ".dot");
            m_ReportingServices.AddThompsonStepToReporting(m_NFA);

            return(m_NFA);
        }
Beispiel #4
0
        /// <summary>
        /// Dijkstra寻路入口
        /// </summary>
        /// <param name="graph">整张图的数据</param>
        /// <param name="start">开始节点id</param>
        /// <param name="end">结束节点id</param>
        /// <returns></returns>
        public bool FindPath(List <CGraphNode> graph, int start, int end)
        {
            CGraphNode startNode = graph[start];
            CGraphNode endNode   = graph[end];

            return(FindPath(startNode, endNode));
        }
    protected FAInfo UpdateClosureInformation(FA synth, FA currentFA, CGraph.CMergeGraphOperation mergeOperation)
    {
        FAInfo closureOperandInfo = synth.GetFAInfo();     // get access to the closure operand FA
        FAInfo currentFAInfo      = currentFA.GetFAInfo(); // get access to the current FA info

        foreach (FALoop faLoop in closureOperandInfo.MLoopsInFa.Values)
        {
            FALoop     newloop = new FALoop();
            CGraphNode entry   = faLoop.MEntryNode;
            newloop.MEntryNode = mergeOperation.GetMirrorNode(entry);
            CGraphNode exit = faLoop.MExitNode;
            newloop.MExitNode = mergeOperation.GetMirrorNode(exit);
            foreach (CGraphNode cGraphNode in faLoop.MParticipatingNodes)
            {
                newloop.MParticipatingNodes.Add(mergeOperation.GetMirrorNode(cGraphNode));
            }
            FALoop.ClosureType closureType = faLoop.MClosureType;
            Range <int>        clsrng      = faLoop.MClosureRange;
            if (clsrng != null)
            {
                newloop.MClosureRange = new Range <int>(clsrng);
            }
            newloop.MClosureType = faLoop.MClosureType;
            newloop.MLoopSerial  = faLoop.MLoopSerial;
            currentFAInfo.AddFALoop(newloop);
        }

        return(currentFAInfo);
    }
Beispiel #6
0
        public override FA VisitRange(CASTElement currentNode)
        {
            CRange           rangeNode = currentNode as CRange;
            FAGraphQueryInfo FAInfo;

            //1.Create FA
            m_NFA  = new FA();
            FAInfo = new FAGraphQueryInfo(m_NFA, FA.m_FAINFOKEY);
            //2.Create nodes initial-final
            CGraphNode init  = m_NFA.CreateGraphNode <CGraphNode>();
            CGraphNode final = m_NFA.CreateGraphNode <CGraphNode>();

            m_NFA.M_Initial = init;
            m_NFA.SetFinalState(final);
            m_NFA.M_Alphabet.AddRange(rangeNode.MRange);

            //3.Draw the edge including the character
            CGraphEdge newEdge = m_NFA.AddGraphEdge <CGraphEdge, CGraphNode>(init, final, GraphType.GT_DIRECTED);

            FAInfo.Info(newEdge).M_TransitionCharSet = (CCharRangeSet)rangeNode.MRange;
            newEdge.SetLabel(rangeNode.MRange.ToString());

            m_ReportingServices.ExctractThompsonStep(m_NFA, @"../Debug/Range_" + rangeNode.MRange.ToString() + ".dot");
            m_ReportingServices.AddThompsonStepToReporting(m_NFA);
            //4.Pass FA to the predecessor
            return(m_NFA);
        }
    internal FA Synthesize(CCharRangeSet set)
    {
        FAGraphQueryInfo FAInfo;

        m_currentFA    = new FA();
        m_ThompsonInfo = new ThompsonInfo(m_currentFA, m_ThompsonInfoKey);
        FAInfo         = new FAGraphQueryInfo(m_currentFA, FA.m_FAINFOKEY);

        //2.Create nodes initial-final
        CGraphNode init  = m_currentFA.CreateGraphNode <CGraphNode>();
        CGraphNode final = m_currentFA.CreateGraphNode <CGraphNode>();

        m_ThompsonInfo.InitNodeInfo(init, new ThompsonNodeFAInfo());
        m_ThompsonInfo.InitNodeInfo(final, new ThompsonNodeFAInfo());

        m_currentFA.M_Initial = init;
        m_currentFA.SetFinalState(final);
        m_currentFA.M_Alphabet.AddSet(set);

        //3.Draw the edge including the character
        CGraphEdge newEdge = m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(init, final, GraphType.GT_DIRECTED);

        FAInfo.Info(newEdge).M_TransitionCharSet = set;

        return(m_currentFA);
    }
Beispiel #8
0
    internal FA SynthesizeOneOrNone(FA synth)
    {
        FA tempFA = new FA();

        //2.Merge graph
        CGraph.CMergeGraphOperation merged = tempFA.Merge(synth, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
        merged.MergeGraphInfo(synth, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        merged.MergeGraphInfo(synth, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        merged.MergeGraphInfo(synth, GraphElementType.ET_NODE, FA.m_FAINFOKEY);


        CGraphNode il = tempFA.CreateGraphNode <CGraphNode>();

        tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(il, merged.GetMirrorNode(synth.M_Initial), GraphType.GT_DIRECTED);
        CGraphNode fl = tempFA.CreateGraphNode <CGraphNode>();

        tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(merged.GetMirrorNode(synth.GetFinalStates()[0]), fl, GraphType.GT_DIRECTED);

        //4.Create the initial and the final node
        tempFA.M_Initial = il;
        tempFA.SetFinalState(fl);
        tempFA.UpdateAlphabet();

        tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(il, fl, GraphType.GT_DIRECTED);

        //7.Return result
        return(tempFA);
    }
Beispiel #9
0
    internal FA Synthesize(FA l, FA r)
    {
        FA tempFA = new FA();

        //2.Merge left graph
        CGraph.CMergeGraphOperation lmerge = tempFA.Merge(l, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, FA.m_FAINFOKEY);

        CGraphNode il = lmerge.GetMirrorNode(l.M_Initial);
        CGraphNode fl = lmerge.GetMirrorNode(l.GetFinalStates()[0]);

        //3.Merge right graph
        CGraph.CMergeGraphOperation rmerge = tempFA.Merge(r, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, FA.m_FAINFOKEY);

        CGraphNode ir = rmerge.GetMirrorNode(r.M_Initial);
        CGraphNode fr = rmerge.GetMirrorNode(r.GetFinalStates()[0]);

        //4.Create the initial and the final node
        tempFA.M_Initial = il;
        tempFA.SetFinalState(fr);

        tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(fl, ir, GraphType.GT_DIRECTED);

        //7.Return result
        return(tempFA);
    }
Beispiel #10
0
        protected void Relax(CGraphNode source, CGraphNode target)
        {
            int currentDistance;

            if (Distance(source) != null)
            {
                currentDistance = (int)Distance(source) + Weight(source, target);

                if (Distance(target) != null)
                {
                    if (Distance(target) > currentDistance)
                    {
                        SetDistance(target, currentDistance);
                        SetPredecessor(target, source);
                    }
                }
                else
                {
                    SetDistance(target, currentDistance);
                    SetPredecessor(target, source);
                }
            }
            else
            {
#if DEBUG
                currentDistance = Weight(source, target);
#endif
            }

#if DEBUG
            Console.WriteLine("Relax: {0} -->  {1}  CurrentDistance={2}, Distance={3}, Weight={4}",
                              source.M_Label, target.M_Label, currentDistance, Distance(target), Weight(source, target));
#endif
        }
 public BreadthFirstSearch(CGraphNode mSource, CGraph mGraph)
 {
     m_source        = mSource;
     m_graph         = mGraph;
     m_BFSData       = new BreadthFirstSearchQueryInfo(mGraph, this);
     m_Q             = new Queue <CGraphNode>();
     m_nodeVisitList = new List <CGraphNode>();
 }
Beispiel #12
0
 public BellmanFord(CGraph graph, CGraphNode source, int graphWeightsKey)
 {
     mGraph                 = graph;
     m_source               = source;
     this[m_PATHINFO]       = m_outputShortestPathsInfo = new BellmanFordQueryInfo(graph, this);
     m_inputGraphWeightInfo = new CGraphQueryInfo <object, int, object>(graph, graphWeightsKey);
     m_outputShortestPathsInfo.CreateInfo(m_shortestPaths);
 }
    internal FA Sythesize(FA l, FA r, CGraph.CMergeGraphOperation.MergeOptions options)
    {
        //1.Create FA
        m_currentFA    = new FA();
        m_ThompsonInfo = new ThompsonInfo(m_currentFA, m_ThompsonInfoKey);

        //2.Merge left graph
        CGraph.CMergeGraphOperation lmerge = m_currentFA.Merge(l, options);
        //Console.WriteLine(l.ToString());
        lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, FA.m_FAINFOKEY);

        lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, m_ThompsonInfoKey);

        CGraphNode il = lmerge.GetMirrorNode(l.M_Initial);
        CGraphNode fl = lmerge.GetMirrorNode(l.GetFinalStates()[0]);

        //3.Merge right graph
        CGraph.CMergeGraphOperation rmerge = m_currentFA.Merge(r, options);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, FA.m_FAINFOKEY);

        rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, m_ThompsonInfoKey);

        CGraphNode ir = rmerge.GetMirrorNode(r.M_Initial);
        CGraphNode fr = rmerge.GetMirrorNode(r.GetFinalStates()[0]);

        //4.Create the initial and the final node
        CGraphNode FAinit  = m_currentFA.CreateGraphNode <CGraphNode>();
        CGraphNode FAfinal = m_currentFA.CreateGraphNode <CGraphNode>();

        m_ThompsonInfo.InitNodeInfo(FAinit, new ThompsonNodeFAInfo());
        m_ThompsonInfo.InitNodeInfo(FAfinal, new ThompsonNodeFAInfo());

        m_currentFA.M_Initial = FAinit;
        m_currentFA.SetFinalState(FAfinal);
        m_currentFA.UpdateAlphabet();

        m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(FAinit, il, GraphType.GT_DIRECTED);
        m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(FAinit, ir, GraphType.GT_DIRECTED);
        m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(fr, FAfinal, GraphType.GT_DIRECTED);
        m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(fl, FAfinal, GraphType.GT_DIRECTED);

        // Update closure information from operand closure
        // Update closure information from operand closure
        UpdateClosureInformation(l, m_currentFA, lmerge);
        UpdateClosureInformation(r, m_currentFA, rmerge);

        //7.Return result
        return(m_currentFA);
    }
        public override object VisitChildren(CGraphNode node)
        {
            CIt_Successors it = new CIt_Successors(node);

            for (it.Begin(); !it.End(); it.Next())
            {
                Visit(it.M_CurrentItem);
            }
            return(null);
        }
Beispiel #15
0
        public void FindAllPairsShortestPaths()
        {
            CIt_GraphNodes itn = new CIt_GraphNodes(mGraph);

            for (itn.Begin(); !itn.End(); itn.Next())
            {
                m_source = itn.M_CurrentItem;
                Run();
            }
        }
Beispiel #16
0
 /// <summary>
 /// Adds a node in the specified existing condensed node if it doesn't already
 /// exists in the condensed node
 /// </summary>
 /// <param name="condensedNode"></param>
 /// <param name="node"></param>
 /// <returns></returns>
 public CGraphNode AddNodeToCondensedNode(CGraphNode condensedNode, CGraphNode node)
 {
     if (Contains(condensedNode) != GraphElementType.ET_NA &&
         !CondensedNodeContains(condensedNode, node))
     {
         m_condensedNodeMappings[condensedNode].Add(node);
         m_nodeMappings[node] = condensedNode;
         return(node);
     }
     return(null);
 }
        /// <summary>
        /// Checks to find existing NFA configurations mapped to
        /// existing DFA states with the given set of NFA nodes.
        /// If it finds equivalent configuration it returns the
        /// corresponding DFA state
        /// </summary>
        /// <param name="q">NFA nodes set</param>
        /// <returns>null or the corresponding DFA state</returns>
        public CGraphNode GetDFANode(HashSet <CGraphNode> q)
        {
            CGraphNode DFAnode = null;

            foreach (CGraphNode dfanode in m_mappings.Keys)
            {
                if (m_mappings[dfanode].SetEquals(q))
                {
                    DFAnode = dfanode;
                }
            }
            return(DFAnode);
        }
Beispiel #18
0
        /// <summary>
        /// 寻路start 和 end, 因为GraphNode本身包含图结构的数据
        /// 所以我们没必要传如所有的GraphNode数据了
        /// </summary>
        /// <param name="start">开始节点</param>
        /// <param name="end">结束节点</param>
        /// <returns></returns>
        public bool FindPath(CGraphNode start, CGraphNode end)
        {
            m_open.Clear();
            m_closed.Clear();

            m_startNode = start;
            m_endNode   = end;

            m_startNode.G = 0;
            bool result = Search();

            return(result);
        }
        public bool ContainsInitialState(HashSet <CGraphNode> q)
        {
            CGraphNode initiaNFAState = m_NFA.M_Initial;

            foreach (CGraphNode node in q)
            {
                if (initiaNFAState == node)
                {
                    return(true);
                }
            }
            return(false);
        }
        /// <summary>
        /// Creates a unique dfa node for a given configuration
        /// The method assures that the configuration-dfa node mapping
        /// is unique
        /// </summary>
        /// <param name="q">The q.</param>
        /// <returns></returns>
        public CGraphNode CreateDFANode(HashSet <CGraphNode> q)
        {
            CGraphNode       DFAnode  = null;
            HashSet <string> prefixes = new HashSet <string>();
            string           prefix   = "";

            //check if q configuration corresponds to a DFA state
            DFAnode = GetDFANode(q);
            //if not create a new DFA node
            if (DFAnode == null)
            {
                DFAnode = m_DFA.CreateGraphNode <CGraphNode>();

                foreach (CGraphNode node in q)
                {
                    if (!prefixes.Contains(m_NFAStateInfo.Info(node).M_NodeLabelPrefix))
                    {
                        prefixes.Add(m_NFAStateInfo.Info(node).M_NodeLabelPrefix);
                        m_DFAStateInfo.Info(DFAnode).M_NodeLabelPrefix = m_NFAStateInfo.Info(node).M_NodeLabelPrefix;
                    }

                    foreach (uint lineDependency in m_NFAStateInfo.Info(node).M_LineDependencies)
                    {
                        m_DFA.SetFANodeLineDependency(lineDependency, DFAnode);
                    }
                }

                foreach (string s in prefixes)
                {
                    prefix += s;
                }
                m_DFA.PrefixElementLabel(prefix, DFAnode);


                if (ContainsFinalState(q))
                {
                    m_DFA.SetFinalState(DFAnode);
                }

                if (ContainsInitialState(q))
                {
                    m_DFA.M_Initial = DFAnode;
                }
                m_mappings[DFAnode] = q;
            }
            //else return the existing DFA node
            return(DFAnode);
        }
Beispiel #21
0
        public static void TestCaseBook()
        {
            // 1. Create a graph
            CGraph mgraph = CGraph.CreateGraph();

            CGraphNode r = mgraph.CreateGraphNode <CGraphNode>("r");
            CGraphNode s = mgraph.CreateGraphNode <CGraphNode>("s");
            CGraphNode t = mgraph.CreateGraphNode <CGraphNode>("t");
            CGraphNode u = mgraph.CreateGraphNode <CGraphNode>("u");
            CGraphNode v = mgraph.CreateGraphNode <CGraphNode>("v");
            CGraphNode w = mgraph.CreateGraphNode <CGraphNode>("w");
            CGraphNode x = mgraph.CreateGraphNode <CGraphNode>("x");
            CGraphNode y = mgraph.CreateGraphNode <CGraphNode>("y");

            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(r, s, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(r, v, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(s, w, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, t, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, x, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(t, x, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(t, u, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(x, u, GraphType.GT_UNDIRECTED);
            mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(x, y, GraphType.GT_UNDIRECTED);

            // 2. Create Algorithm
            BreadthFirstSearch bfs = new BreadthFirstSearch(s, mgraph);

            // 2. Associate weights with the edges of the graph
            CGraphQueryInfo <int, int, int> bfsData = new CGraphQueryInfo <int, int, int>(mgraph, bfs);

            bfs.Run();

            Console.WriteLine("Printing BFS Results with Source Node : {0}", s.M_Label);
            foreach (CGraphNode node in bfs.BFSNodes())
            {
                Console.WriteLine("Node {0} distance: {1}", node.M_Label, bfs.Distance(node));
            }

            // Testing BreadthFirstSearchQueryInfo
            BreadthFirstSearchQueryInfo bfsInfo = new BreadthFirstSearchQueryInfo(mgraph, bfs);

            Console.WriteLine("Printing BFS Results with Source Node : {0}", s.M_Label);
            foreach (CGraphNode node in bfsInfo.BFSNodes())
            {
                Console.WriteLine("Node {0} distance: {1}", node.M_Label, bfs.Distance(node));
            }
        }
Beispiel #22
0
        //寻路的具体算法
        private bool Search()
        {
            CGraphNode node = m_startNode;

            while (node != m_endNode)
            {
                for (int i = 0; i < node.NeighbourCount; i++)
                {
                    CGraphNode.Neighbour neighbour = node.Neighbours[i];
                    CGraphNode           test      = neighbour.node;
                    if (test == node)
                    {
                        continue;
                    }
                    if (IsClosed(test))
                    {
                        continue;
                    }


                    float g = node.G + neighbour.cost;
                    if (IsOpen(test))
                    {
                        if (test.G > g)
                        {
                            test.FillValue(g, node);
                        }
                    }
                    else
                    {
                        test.FillValue(g, node);
                        m_open.Push(test);
                    }
                }
                m_closed.Add(node);

                if (m_open.Count == 0)
                {
                    return(false);
                }
                node = m_open.Pop();
            }
            BuildPath();
            return(true);
        }
Beispiel #23
0
 /// <summary>
 /// Returns the information of the edge between the given source
 /// and target nodes of the source graph. If the information is
 /// not there it returns null instead of dropping an exception
 /// </summary>
 /// <param name="source">The source.</param>
 /// <param name="target">The target.</param>
 /// <param name="key">The key that will extract the information from the specified node's dictionary.If
 /// null is given then the current Query Info object is used as a key</param>
 /// <returns></returns>
 public override IE Info(CGraphNode source, CGraphNode target, bool checkOwnership = true)
 {
     if (!checkOwnership)
     {
         return((IE)m_graph.Edge(source, target)[m_infoKey]);
     }
     else
     {
         if (source.M_OwnerGraph == m_graph && target.M_OwnerGraph == m_graph)
         {
             return((IE)m_graph.Edge(source, target)[m_infoKey]);
         }
         else
         {
             throw new Exception("The given edge does not belong to the graph");
         }
     }
 }
Beispiel #24
0
 public override IN TempInfo(CGraphNode node, bool checkOwnership = true)
 {
     if (!checkOwnership)
     {
         return((IN)node[node]);
     }
     else
     {
         if (node.M_OwnerGraph == m_graph)
         {
             return((IN)node[node]);
         }
         else
         {
             throw new Exception("The given node does not belong to the graph");
         }
     }
 }
Beispiel #25
0
 public override void CreateTempInfo(CGraphNode node, IN info, bool checkOwnership = true)
 {
     if (!checkOwnership)
     {
         node[node] = info;
     }
     else
     {
         if (node.M_OwnerGraph == m_graph)
         {
             node[node] = info;
         }
         else
         {
             throw new Exception("The given node does not belong to the graph");
         }
     }
 }
Beispiel #26
0
 /// <summary>
 /// Stores the information at the specified edge of the source graph. If information already
 /// exists, it is overwritten
 /// </summary>
 /// <param name="source">The source node.</param>
 /// <param name="target">The target node.</param>
 /// <param name="info">The information.</param>
 /// <param name="key">The key that will extract the information from the specified node's dictionary. If
 /// null is given then the current Query Info object is used as a key</param>
 public override void CreateInfo(CGraphNode source, CGraphNode target, IE info, bool checkOwnership = true)
 {
     if (!checkOwnership)
     {
         m_graph.Edge(source, target)[m_infoKey] = info;
     }
     else
     {
         if (source.M_OwnerGraph == m_graph && target.M_OwnerGraph == m_graph)
         {
             m_graph.Edge(source, target)[m_infoKey] = info;
         }
         else
         {
             throw new Exception("The given edge does not belong to the graph");
         }
     }
 }
    internal FA Synthesize(FA l, FA r)
    {
        FA m_currentFA = new FA();

        m_ThompsonInfo = new ThompsonInfo(m_currentFA, m_ThompsonInfoKey);
        //2.Merge left graph
        CGraph.CMergeGraphOperation lmerge = m_currentFA.Merge(l, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, FA.m_FAINFOKEY);

        lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
        lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, m_ThompsonInfoKey);

        CGraphNode il = lmerge.GetMirrorNode(l.M_Initial);
        CGraphNode fl = lmerge.GetMirrorNode(l.GetFinalStates()[0]);

        //3.Merge right graph
        CGraph.CMergeGraphOperation rmerge = m_currentFA.Merge(r, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, FA.m_FAINFOKEY);

        rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
        rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, m_ThompsonInfoKey);

        CGraphNode ir = rmerge.GetMirrorNode(r.M_Initial);
        CGraphNode fr = rmerge.GetMirrorNode(r.GetFinalStates()[0]);

        //4.Create the initial and the final node
        m_currentFA.M_Initial = il;
        m_currentFA.SetFinalState(fr);

        m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(fl, ir, GraphType.GT_DIRECTED);

        // Update closure information from operand closure
        UpdateClosureInformation(l, m_currentFA, lmerge);
        UpdateClosureInformation(r, m_currentFA, rmerge);

        //7.Return result
        return(m_currentFA);
    }
Beispiel #28
0
        private void BuildPath()
        {
            m_path.Clear();
            CGraphNode node = m_endNode;

            m_path.Push(node);

            while (node != m_startNode)
            {
                node = node.Parent;
                m_path.Push(node);
            }

            /* remove the first node which indeed is start node */
            if (m_path.Count > 0)
            {
                m_path.Pop();
            }
        }
        public override int Visit(CGraphNode node)
        {
            m_time++;
            SetArrival(node, m_time);
            SetColor(node, NodeColor.NC_GRAY);
            CIt_Successors si = new CIt_Successors(node);

            for (si.Begin(); !si.End(); si.Next())
            {
                if (Color(si.M_CurrentItem) == NodeColor.NC_WHITE)
                {
                    Visit(si.M_CurrentItem);
                }
            }
            SetColor(node, NodeColor.NC_BLACK);
            m_time++;
            SetDeparture(node, m_time);
            return(0);
        }
Beispiel #30
0
 // Works only for the initial DFA's nodes
 public CGraphNode GetTargetNodeConfiguration(CGraphNode node, Int32 character)
 {
     if (m_DFA.IsANodeOfGraph(node))
     {
         CGraphNode target = m_DFA.GetTransitionTarget(node, character);
         if (target != null)
         {
             return(GetNodeConfiguration(target) as CGraphNode);
         }
         else
         {
             return(null);
         }
     }
     else
     {
         return(null);
     }
 }