public void GraphWithSelfEdgesPUT1(int v, int e, bool self)
        {
            AdjacencyGraph g = null;

            RandomGraph.Graph(g, v, e, new Random(), self);
            DepthFirstSearchAlgorithm bfs = new DepthFirstSearchAlgorithm(g);
        }
        public void GraphWithoutSelfEdges()
        {
            AdjacencyGraph g = new AdjacencyGraph(
                new QuickGraph.Providers.VertexAndEdgeProvider(),
                true);

            RandomGraph.Graph(g, 20, 100, new Random(), false);

            DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(g);

            dfs.StartVertex        += new VertexHandler(this.StartVertex);
            dfs.DiscoverVertex     += new VertexHandler(this.DiscoverVertex);
            dfs.ExamineEdge        += new EdgeHandler(this.ExamineEdge);
            dfs.TreeEdge           += new EdgeHandler(this.TreeEdge);
            dfs.BackEdge           += new EdgeHandler(this.BackEdge);
            dfs.ForwardOrCrossEdge += new EdgeHandler(this.FowardOrCrossEdge);
            dfs.FinishVertex       += new VertexHandler(this.FinishVertex);

            Parents.Clear();
            DiscoverTimes.Clear();
            FinishTimes.Clear();
            m_Time = 0;

            foreach (IVertex v in g.Vertices)
            {
                Parents[v] = v;
            }

            // compute
            dfs.Compute();

            CheckDfs(g, dfs);
        }
 protected override bool ContainsOption(RandomGraph.Common.Model.AnalyseOptions option)
 {
     switch (option)
     {
         case AnalyseOptions.ClusteringCoefficient:
             return assemblyToAnalyze[0].CoefficientsLocal.Keys.Count != 0;
         case AnalyseOptions.DegreeDistribution:
             return assemblyToAnalyze[0].VertexDegreeLocal.Keys.Count != 0;
         case AnalyseOptions.ConnSubGraph:
             return assemblyToAnalyze[0].SubgraphsLocal.Keys.Count != 0;
         case AnalyseOptions.MinPathDist:
             return assemblyToAnalyze[0].DistanceBetweenVerticesLocal.Count != 0;
         case AnalyseOptions.EigenValue:
             return assemblyToAnalyze[0].Results[0].EigenVector.Count != 0;
         case AnalyseOptions.DistEigenPath:
             return assemblyToAnalyze[0].DistancesBetweenEigenValuesLocal.Count != 0;
         case AnalyseOptions.Cycles:
             return assemblyToAnalyze[0].Results[0].Cycles.Count != 0;
         case AnalyseOptions.TriangleCountByVertex:
             return assemblyToAnalyze[0].Results[0].TriangleCount.Count != 0;
         case AnalyseOptions.TriangleTrajectory:
             return assemblyToAnalyze[0].TriangleTrajectoryLocal.Count != 0;
         default:
             return assemblyToAnalyze[0].Results[0].Result.Keys.Contains(option);
     }
 }
        /// Summary
        /// Time: 4 min 52 sec
        /// Pattern: Parameterized stub
        public void RemoveEdgeIf(BidirectionalGraph g)
        {
            IEdge e = RandomGraph.Edge(g, Rnd);

            g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, false));
            g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, true));
        }
        public void RemoveEdgeIf()
        {
            IMutableEdgeListGraph g = Graph;
            IEdge e = RandomGraph.Edge(g, Rnd);

            g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, false));
            g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, true));
        }
        private void AddRandom_Click(object sender, RoutedEventArgs e)
        {
            ViewModel.Current.Graphs.Add(RandomGraph.Get());

            //for (int i = 0; i < 10; i++)
            //{
            //       graphs.Add(new RandomGraph());
            //}
        }
示例#7
0
        /// Summary
        /// Time: 1 min 59 sec
        /// Pattern: AAAA, AllowedException
        public void AddRemoveVertexNotFound([PexAssumeUnderTest] AdjacencyGraph g)
        {
            IVertex v = RandomGraph.Vertex(g, new Random());

            g.RemoveVertex(v);
            PexAssert.IsFalse(g.ContainsVertex(v));
            g.RemoveVertex(v);
            PexAssert.IsTrue(false, "ArgumentNullException was expected");
        }
示例#8
0
        public Result Test(StreamWriter tw, int graphSize, double saturation, bool useBrute)
        {
            Result res   = new Result();
            Graph  graph = RandomGraph.GenerateGraph(graphSize, saturation);

            res.vertices = graphSize;
            res.edges    = graph.EdgesCount;

            int[]     result;
            long      elapsedMs;
            Stopwatch watch;

            if (useBrute)
            {
                watch  = System.Diagnostics.Stopwatch.StartNew();
                result = BruteForce.Solve(ref graph);
                watch.Stop();
                elapsedMs = watch.ElapsedMilliseconds;
                bool tmp = graph.IsColoringValid();
                res.bruteChromaticNum = graph.ChromaticNumber();
                res.bruteTimeMs       = elapsedMs;
                res.bruteValid        = graph.IsColoringValid();
            }

            watch  = System.Diagnostics.Stopwatch.StartNew();
            result = SmallestLast.Solve(ref graph);
            watch.Stop();
            elapsedMs = watch.ElapsedMilliseconds;
            res.smallestlastChromaticNum = graph.ChromaticNumber();
            res.smallestlastTimeMs       = elapsedMs;
            res.smallestlastValid        = graph.IsColoringValid();

            watch  = System.Diagnostics.Stopwatch.StartNew();
            result = DSatur.Solve(ref graph);
            watch.Stop();
            elapsedMs = watch.ElapsedMilliseconds;
            res.dsaturChromaticNum = graph.ChromaticNumber();
            res.dsaturTimeMs       = elapsedMs;
            res.dsaturValid        = graph.IsColoringValid();

            watch  = System.Diagnostics.Stopwatch.StartNew();
            result = BFSColoring.Solve(ref graph);
            watch.Stop();
            elapsedMs           = watch.ElapsedMilliseconds;
            res.bfsChromaticNum = graph.ChromaticNumber();
            res.bfsTimeMs       = elapsedMs;
            res.bfsValid        = graph.IsColoringValid();

            tw.WriteLine(String.Format("{0};{1};{2};{3};{4};{5};{6};{7};{8};{9};{10};{11};{12};{13};", res.bruteTimeMs, res.bruteChromaticNum, res.bruteValid,
                                       res.smallestlastTimeMs, res.smallestlastChromaticNum, res.smallestlastValid, res.smallestlastChromaticNum - res.bruteChromaticNum,
                                       res.bfsTimeMs, res.bfsChromaticNum, res.bfsValid, res.bfsChromaticNum - res.bruteChromaticNum,
                                       res.dsaturTimeMs, res.dsaturChromaticNum, res.dsaturValid, res.dsaturChromaticNum - res.bruteChromaticNum));

            return(res);
        }
示例#9
0
        /// Summary
        /// Time: 1 min 8 sec
        /// Pattern: AAAA, Allowed Exception
        public void AddEdgeTargetNotFound([PexAssumeUnderTest] AdjacencyGraph g)
        {
            IVertex v      = RandomGraph.Vertex(g, new Random());
            IVertex target = RandomGraph.Vertex(g, new Random());

            PexAssume.IsTrue(v != target);
            g.RemoveVertex(target);
            IEdge e = g.AddEdge(v, target);

            PexAssert.IsTrue(false);   //Should not be reached
        }
示例#10
0
        /// Summary
        /// Time: 1 min 3 sec
        /// Pattern: AAAA, Allowed Exception
        public void AddEdgeSourceNotFound([PexAssumeUnderTest] AdjacencyGraph g)
        {
            IVertex v      = RandomGraph.Vertex(g, new Random());
            IVertex source = RandomGraph.Vertex(g, new Random());

            PexAssume.IsTrue(v != source);
            g.RemoveVertex(source);
            IEdge e = g.AddEdge(source, v);

            PexAssert.IsTrue(false);        //Should not be reached
        }
        public void tooManyConnectionsTest()
        {
            Graph g = RandomGraph.Generate(20, 1.1, 1);

            Assert.AreEqual(20, g.GetMap().Count);

            foreach (KeyValuePair <int, List <int> > entry in g.GetMap())
            {
                Assert.AreEqual(19, entry.Value.Count);
            }
        }
        public void normalTest()
        {
            Graph g = RandomGraph.Generate(20, 0.5, 1);

            Assert.AreEqual(20, g.GetMap().Count);

            foreach (KeyValuePair <int, List <int> > entry in g.GetMap())
            {
                Assert.IsNotNull(entry.Value);
            }
        }
示例#13
0
        public void RemoveEdgeIf(IMutableEdgeListGraph g)
        {
            if (g.EdgesEmpty)
            {
                return;
            }

            IEdge e = RandomGraph.Edge(g, Rnd);

            g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, false));
            g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, true));
        }
示例#14
0
        public static int RunTest(int n)
        {
            IRandomGraph g = new RandomGraph(n);
            int          c = 0;

            while (!g.IsConnected())
            {
                c++;
                g.NextEdge();
            }

            return(c);
        }
        public void GraphWithoutSelfEdges()
        {
            RandomGraph.Graph(g, 20, 100, new Random(), false);

            foreach (IVertex v in g.Vertices)
            {
                Parents[v] = v;
            }

            // compute
            dfs.Compute();

            CheckDfs();
        }
示例#16
0
    private void gerarAlternativo(out List <GameObject> thisLevelNodes)
    {
        thisLevelNodes = new List <GameObject>();
        RandomGraph rg = new RandomGraph(numPoints, maxDistance, minDistance);

        foreach (var v in rg.PopulateVertices())
        {
            var go = fac.SpawnNetworkNode(Random.Range(3, 6), Random.Range(0, 6) * 15, NetworkNode.NodeState.NS_Visible, getPosition(v.x, v.y));
            thisLevelNodes.Add(go);
            v.tag = go;
        }

        // gerar arestas
        int numcons = 0;

        foreach (var e in rg.PopulateEdges(forgiveDistance))
        {
            numcons++;
            fac.CreateConnection((GameObject)e.A.tag, (GameObject)e.B.tag);
        }

        // gerar nos 0 - 2
        NetworkNode inputNode = null;

        for (int i = 0; i < 3; i++)
        {
            RandomGraph.Vertex p;
            var v  = rg.CreateNew(out p);
            var go = fac.SpawnNetworkNode(i, Random.Range(0, 6) * 15, NetworkNode.NodeState.NS_Visible, getPosition(v.x, v.y));
            thisLevelNodes.Add(go);
            v.tag = go;

            fac.CreateConnection((GameObject)v.tag, (GameObject)p.tag);

            if (i == 0)
            {
                inputNode = go.GetComponent <NetworkNode>();
            }
        }

        // ativar nos conectados
        foreach (var conn in inputNode.Connetions)
        {
            var other = conn.nodes[0].netnode == inputNode ? conn.nodes[1].netnode : conn.nodes[0].netnode;
            other.State = NetworkNode.NodeState.NS_Active;
        }
        Debug.Log("LEVEL GERADO COM ALGORITMO RESERVA!!!");
    }
示例#17
0
        public void concurrencyRandomGraphTest()
        {
            int size = 60;

            foreach (SCCDetector detector in this.concurrentDetectors)
            {
                Graph g        = RandomGraph.Generate(size, 0.05, 4);
                Graph original = new Graph(g.GetMap());

                ResultSet results = detector.Compute(g);

                for (int i = 0; i < results.List.Count; i++)
                {
                    Assert.IsTrue(original.IsSCC(results.List[i]));
                }
            }
        }
示例#18
0
        /// Summary
        /// Time: 8 min 17 sec
        /// Pattern: AAAA, Parameterized stub
        /// Pex Limitations - Not able to generate any test due to the following issue:
        /// <boundary> maxbranches - 40000 (maximum number of branches exceeded)
        /// [execution] Please notice: A branch in the method System.Collections.Hashtable+HashtableEnumerator.MoveNext was executed 5777 times;
        /// please check that the code is not stuck in an infinite loop.
        /// [test] (run 1) GraphWithoutSelfEdgesPUT01, pathboundsexceeded (duplicate)
        /// [execution] Please notice: A branch in the method System.Collections.Hashtable+HashtableEnumerator.MoveNext was executed 4344 times;
        /// please check that the code is not stuck in an infinite loop.
        /// [test] (run 2) GraphWithoutSelfEdgesPUT01, pathboundsexceeded (duplicate)
        /// <summary>
        /// @Author:Madhuri
        /// </summary>
        public void GraphWithSelfEdgesPUT(AdjacencyGraph g, int loopBound)
        {
            Random rnd = new Random();

            Init();
            for (int i = 0; i < loopBound; ++i)
            {
                for (int j = 0; j < i * i; ++j)
                {
                    RandomGraph.Graph(g, i, j, rnd, true);
                    BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(g);
                    bfs.InitializeVertex += new VertexHandler(this.InitializeVertex);
                    bfs.DiscoverVertex   += new VertexHandler(this.DiscoverVertex);
                    bfs.ExamineEdge      += new EdgeHandler(this.ExamineEdge);
                    bfs.ExamineVertex    += new VertexHandler(this.ExamineVertex);
                    bfs.TreeEdge         += new EdgeHandler(this.TreeEdge);
                    bfs.NonTreeEdge      += new EdgeHandler(this.NonTreeEdge);
                    bfs.GrayTarget       += new EdgeHandler(this.GrayTarget);
                    bfs.BlackTarget      += new EdgeHandler(this.BlackTarget);
                    bfs.FinishVertex     += new VertexHandler(this.FinishVertex);

                    Parents.Clear();
                    Distances.Clear();
                    m_CurrentDistance = 0;

                    m_SourceVertex = RandomGraph.Vertex(g, rnd);
                    var choose = PexChoose.FromCall(this);
                    if (choose.ChooseValue <bool>("to add a self ede"))
                    {
                        IVertex selfEdge = RandomGraph.Vertex(g, rnd);
                        g.AddEdge(selfEdge, selfEdge);
                    }
                    // g.RemoveEdge(RandomGraph.Edge(g, rnd));
                    foreach (IVertex v in g.Vertices)
                    {
                        Distances[v] = int.MaxValue;
                        Parents[v]   = v;
                    }
                    Distances[SourceVertex] = 0;
                    bfs.Compute(SourceVertex);

                    CheckBfs(g, bfs);
                }
            }
        }
        public void GraphWithSelfEdgesPUT(AdjacencyGraph g, int loopBound, bool self)
        {
            Random rnd; //new Random();
            var    choose1 = PexChoose.FromCall(this);

            rnd = choose1.ChooseValue <Random>("Random object");
            Init();
            for (int i = 0; i < loopBound; ++i)
            {
                for (int j = 0; j < i * i; ++j)
                {
                    RandomGraph.Graph(g, i, j, rnd, true);
                    Init();
                    DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(g);
                    dfs.StartVertex        += new VertexHandler(this.StartVertex);
                    dfs.DiscoverVertex     += new VertexHandler(this.DiscoverVertex);
                    dfs.ExamineEdge        += new EdgeHandler(this.ExamineEdge);
                    dfs.TreeEdge           += new EdgeHandler(this.TreeEdge);
                    dfs.BackEdge           += new EdgeHandler(this.BackEdge);
                    dfs.ForwardOrCrossEdge += new EdgeHandler(this.FowardOrCrossEdge);
                    dfs.FinishVertex       += new VertexHandler(this.FinishVertex);

                    Parents.Clear();
                    DiscoverTimes.Clear();
                    FinishTimes.Clear();
                    m_Time = 0;

                    foreach (IVertex v in g.Vertices)
                    {
                        Parents[v] = v;
                    }

                    var choose = PexChoose.FromCall(this);
                    if (choose.ChooseValue <bool>("to add a self ede"))
                    {
                        IVertex selfEdge = RandomGraph.Vertex(g, rnd);
                        g.AddEdge(selfEdge, selfEdge);
                    }
                    // compute
                    dfs.Compute();

                    CheckDfs(g, dfs);
                }
            }
        }
示例#20
0
        public void GraphWithSelfEdges()
        {
            Random rnd = new Random();

            for (int i = 0; i < 10; ++i)
            {
                for (int j = 0; j < i * i; ++j)
                {
                    AdjacencyGraph g = new AdjacencyGraph(
                        new QuickGraph.Providers.VertexProvider(),
                        new QuickGraph.Providers.EdgeProvider(),
                        true);
                    RandomGraph.Graph(g, i, j, rnd, true);

                    BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(g);
                    bfs.InitializeVertex += new VertexEventHandler(this.InitializeVertex);
                    bfs.DiscoverVertex   += new VertexEventHandler(this.DiscoverVertex);
                    bfs.ExamineEdge      += new EdgeEventHandler(this.ExamineEdge);
                    bfs.ExamineVertex    += new VertexEventHandler(this.ExamineVertex);
                    bfs.TreeEdge         += new EdgeEventHandler(this.TreeEdge);
                    bfs.NonTreeEdge      += new EdgeEventHandler(this.NonTreeEdge);
                    bfs.GrayTarget       += new EdgeEventHandler(this.GrayTarget);
                    bfs.BlackTarget      += new EdgeEventHandler(this.BlackTarget);
                    bfs.FinishVertex     += new VertexEventHandler(this.FinishVertex);

                    Parents.Clear();
                    Distances.Clear();
                    m_CurrentDistance = 0;
                    m_SourceVertex    = RandomGraph.Vertex(g, rnd);

                    foreach (IVertex v in g.Vertices)
                    {
                        Distances[v] = int.MaxValue;
                        Parents[v]   = v;
                    }
                    Distances[SourceVertex] = 0;
                    bfs.Compute(SourceVertex);

                    CheckBfs(g, bfs);
                }
            }
        }
示例#21
0
文件: Class1.cs 项目: wsgan001/asegrp
        static void Main(string[] args)
        {
            try
            {
/*
 *                              VertexStringDictionary verticesNames = new VertexStringDictionary();
 *                              EdgeStringDictionary edgesNames = new EdgeStringDictionary();
 *                              EdgeDoubleDictionary edgesWeights = new EdgeDoubleDictionary();
 *                              IncidenceGraph g = new IncidenceGraph(true);
 *
 *                              // adding vertex
 *                              Vertex u = g.AddVertex();
 *                              verticesNames[u]="u";
 *                              Vertex v = g.AddVertex();
 *                              verticesNames[v]="v";
 *                              Vertex w = g.AddVertex();
 *                              verticesNames[w]="w";
 *                              Vertex x = g.AddVertex();
 *                              verticesNames[x]="x";
 *                              Vertex y = g.AddVertex();
 *                              verticesNames[y]="y";
 *                              Vertex z = g.AddVertex();
 *                              verticesNames[z]="z";
 *
 *                              // adding edges
 *                              Edge uv = g.AddEdge(u,v);
 *                              edgesNames[uv]="uv";
 *                              edgesWeights[uv]=1;
 *                              Edge ux = g.AddEdge(u,x);
 *                              edgesNames[ux]="ux";
 *                              edgesWeights[ux]=0.8;
 *                              Edge wu = g.AddEdge(w,u);
 *                              g.AddEdge(w,u);
 *                              edgesNames[wu]="wu";
 *                              edgesWeights[wu]=0.2;
 *                              Edge xv = g.AddEdge(x,v);
 *                              edgesNames[xv]="xv";
 *                              edgesWeights[xv]=1.1;
 *                              Edge vy = g.AddEdge(v,y);
 *                              edgesNames[vy]="vy";
 *                              edgesWeights[vy]=2.0;
 *                              Edge wy = g.AddEdge(w,y);
 *                              edgesNames[wy]="wy";
 *                              edgesWeights[wy]=1.5;
 *                              Edge yw = g.AddEdge(y,w);
 *                              edgesNames[yw]="yw";
 *                              edgesWeights[yw]=0.2;
 *                              Edge wz = g.AddEdge(w,z);
 *                              edgesNames[wz]="wz";
 *                              edgesWeights[wz]=0.1;
 *
 *                              RandomGraph.Graph(g, 20,50,new Random(),true);
 *
 * /*
 *                              // do a dfs serach
 *                              Console.WriteLine("---- DepthFirstSearch");
 *                              DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(g);
 *                              //TestDepthFirstSearchVisitor dfsVis =
 *                              //	new TestDepthFirstSearchVisitor(dfs,verticesNames);
 *                              AlgorithmTracerVisitor dfstracer = new
 *                                      AlgorithmTracerVisitor(g,"dfs",".",GraphvizImageType.Png);
 *                              dfstracer.VertexLabels = verticesNames;
 *                              dfstracer.RegisterVertexHandlers(dfs);
 *                              dfstracer.RegisterEdgeHandlers(dfs);
 *
 *                              dfs.Compute();
 */

                Vertex source = u;
                source = RandomGraph.Vertex(g, new Random());
                Console.WriteLine("source: {0}", source.GetHashCode());
                Console.WriteLine("---- BreathFirstSearch");
                BreadthFirstSearchAlgorithm   bfs = new BreadthFirstSearchAlgorithm(g);
                TestBreadthFirstSearchVisitor bfsVis
                    = new TestBreadthFirstSearchVisitor(bfs, verticesNames, source);

                AlgorithmTracerVisitor bfstracer = new
                                                   AlgorithmTracerVisitor(g, "bfs", ".", GraphvizImageType.Png);
//				bfstracer.VertexLabels = verticesNames;
                bfs.RegisterTreeEdgeBuilderHandlers(bfsTracer);
                bfs.RegisterVertexColorizeHandlers(bfsTracer);

                bfs.Compute(source);

/*
 *                              Console.WriteLine("---- Dijkstra");
 *                              DijkstraShortestPathAlgorithm dij = new DijkstraShortestPathAlgorithm(
 *                                      g,
 *                                      edgesWeights
 *                                      );
 *                              TestDijkstraShortestPathVisitor dijVis = new TestDijkstraShortestPathVisitor(dij,verticesNames);
 *                              AlgorithmTracerVisitor dijtracer = new
 *                                      AlgorithmTracerVisitor(g,"dij",".",GraphvizImageType.Png);
 *                              dijtracer.VertexLabels = verticesNames;
 *                              dijtracer.EdgeLabels = edgesWeights;
 *                              dijtracer.RegisterVertexHandlers(dij);
 * //				dijtracer.RegisterEdgeHandlers(dij);
 *                              dij.Compute(g.Vertex(0));
 *
 *                              Console.WriteLine("Distance from {0}", verticesNames[g.Vertex(0)]);
 *                              foreach(DictionaryEntry de in dij.Distances)
 *                              {
 *
 *                                      Console.WriteLine("\t-> {0}, {1}",
 *                                              verticesNames[(Vertex)de.Key],
 *                                              de.Value.ToString()
 *                                              );
 *                              }
 *
 *                              Console.WriteLine("---- Topological sort");
 *                              VertexCollection vs = new VertexCollection();
 *                              TopologicalSortAlgorithm tps= new TopologicalSortAlgorithm(g);
 *                              tps.Compute(vs);
 *                              foreach(Vertex ve in vs)
 *                              {
 *                                      Console.WriteLine("v - {0}",verticesNames[ve]);
 *                              }
 *
 *                              Console.WriteLine("--- graphviz output");
 *                              GraphvizWriterAlgorithm gw = new GraphvizWriterAlgorithm(
 *                                      g,"dotgenerator",".",GraphvizImageType.Png);
 *                              TestGraphvizVertex gv = new TestGraphvizVertex(verticesNames);
 *                              gw.WriteVertex += new VertexHandler( gv.WriteVertex );
 *                              gw.WriteEdge+= new EdgeHandler( gv.WriteEdge );
 *                              gw.Write(GraphvizImageType.Png);
 *                              gw.Write(GraphvizImageType.Svg);
 *                              gw.Write(GraphvizImageType.Svgz);
 *                              gw.Write(GraphvizImageType.Gif);
 *                              gw.Write(GraphvizImageType.Jpeg);
 */
                Console.WriteLine("Test finished");
                String s2 = Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                String s = Console.ReadLine();
            }
        }
 // Use this for initialization
 void Start()
 {
     MyGraph = new RandomGraph(maxX, maxY, desiredNodes, TravelCostMin, TravelCostMax);
     MyGraph.PopulateGraph();
 }
示例#23
0
 private static Graph CreateRandomGraph(int n, double p, SCCDetector[] detectors, int threads)
 {
     return(RandomGraph.Generate(n, p, threads));
 }
        public void emptyTest()
        {
            Graph g = RandomGraph.Generate(0, 0, 1);

            Assert.AreEqual(0, g.GetMap().Count);
        }
示例#25
0
    private void GenerateRandomLevel()
    {
        List <GameObject> thisLevelNodes = new List <GameObject>();
        bool hiddenLevel = Random.value > 0.7f;

        int iterations = 0;

        while (thisLevelNodes.Count <= 0) // repetir até haver um nível corretamente mapeado
        {
            iterations++;
            if (iterations > maxIterations)
            {
                gerarAlternativo(out thisLevelNodes);
                break;
            }

            RandomGraph rg       = new RandomGraph(numPoints, maxDistance, minDistance);
            var         vertices = new List <RandomGraph.Vertex>(rg.PopulateVertices());
            var         edges    = rg.PopulateEdges(forgiveDistance);

            var hanging = vertices.FindAll(test => test.edges.Count == 1);
            Debug.Log("Pendurados: " + hanging.Count + " Tentativas " + iterations);
            if (hanging.Count < 3)  // ao menos tres pendurados
            {
                continue;
            }

            NetworkNode inputNode = null;
            for (int i = 0; i < 3; i++)
            {
                var go = fac.SpawnNetworkNode(i, Random.Range(0, 7) * 15, NetworkNode.NodeState.NS_Visible, getPosition(hanging[i].x, hanging[i].y));
                hanging[i].tag = go;
                thisLevelNodes.Add(go);

                if (i == 0)
                {
                    inputNode = go.GetComponent <NetworkNode>();
                }
            } // coloar input firewall e registro

            foreach (var v in vertices)
            {
                if (v.tag != null)
                {
                    continue;
                }

                var go = fac.SpawnNetworkNode(Random.Range(3, 7), Random.Range(0, 6) * 15, hiddenLevel ? NetworkNode.NodeState.NS_Hidden : NetworkNode.NodeState.NS_Visible, getPosition(v.x, v.y));
                thisLevelNodes.Add(go);
                v.tag = go;
            }

            // gerar arestas
            foreach (var e in edges)
            {
                fac.CreateConnection((GameObject)e.A.tag, (GameObject)e.B.tag);
            }

            foreach (var conn in inputNode.Connetions)
            {
                var other = conn.nodes[0].netnode == inputNode ? conn.nodes[1].netnode : conn.nodes[0].netnode;
                other.State = NetworkNode.NodeState.NS_Active;
            }
        }

        GameManager.listOfNodesAdd(thisLevelNodes.ToArray());
    }