public GraphDS(int nV, int nE)
        {
            this.V = nV;
            this.E = nE;
            Edges  = new EdgeDS[E];

            for (int i = 0; i < E; i++)
            {
                Edges[i] = new EdgeDS();
            }
        }
Example #2
0
        public EdgeDS[] KruskalMST()
        {
            // This will store the resultant MST
            EdgeDS[] mstEdges = new EdgeDS[myGraph.V - 1];
            for (int i = 0; i < myGraph.V - 1; i++)
            {
                mstEdges[0] = new EdgeDS();
            }

            // Step 1: Sort all the edges in non-decreasing order of their weight.
            // If we are not allowed to change the given graph, we can create a copy of array of edges.
            Array.Sort(myGraph.Edges);

            // Step 2: Allocate memory for creating V ssubsets
            SubsetDS[] subsets = new SubsetDS[myGraph.V];
            for (int i = 0; i < myGraph.V; i++)
            {
                subsets[i] = new SubsetDS(i, 0);
            }

            // Step 3: Number of Edges to be taken is V - 1
            int edgesCounter = 0;
            int nERequired   = 0;

            while (nERequired < myGraph.V - 1)
            {
                // Step 4: Pick the smallest edge. And increment the index for next iteration
                EdgeDS edge = new EdgeDS();
                edge = myGraph.Edges[edgesCounter++];

                int xRoot = myGraph.FindRoot(subsets, edge.Src);
                int yRoot = myGraph.FindRoot(subsets, edge.Dest);

                // Step 5: If including this edge does't cause cycle, include it in result and increment the index of result for next edge
                if (xRoot != yRoot)
                {
                    mstEdges[nERequired++] = edge;
                    myGraph.DoUnion(subsets, xRoot, yRoot);
                }
            }

            return(mstEdges);
        }
Example #3
0
    void TestLoadGraph()
    {
        int kern = cs.FindKernel("HookesLaw");

        print(kern);

        cs.SetFloat("springLength", _springLength);
        cs.SetFloat("springk", springk);

        //RenderTexture tex = new RenderTexture(256, 256, 24);
        // renderTarget.enableRandomWrite = true;
        renderTarget.Create();
//
//		cs.SetTexture(kern, "res", renderTarget);
//		cs.Dispatch(kern, 50, 50, 1);
//
        var nodeLookup = new Dictionary <string, Node>();

        var sr = new System.IO.StringReader(_dataFile.text);

        //var lines = _dataFile.text.Split(new string[]{"\r\n", "\r", "\n"}, StringSplitOptions.None);
        while (true)
        {
            var line = sr.ReadLine();
            if (line == null)
            {
                break;
            }
            if (line.Trim().Length > 0)
            {
                var tokens = line.Split(new string[] { "\t", " " }, StringSplitOptions.None);
                var n1tok  = tokens[0];
                var n2tok  = tokens[1];

                if (!nodeLookup.ContainsKey(n1tok))
                {
                    nodeLookup[n1tok] = CreateRandomNode();
                }
                if (!nodeLookup.ContainsKey(n2tok))
                {
                    nodeLookup[n2tok] = CreateRandomNode();
                }

                CreateEdge(nodeLookup[n1tok], nodeLookup[n2tok]);
            }
            if (_nodes.Count >= _maxGraphSize)
            {
                break;
            }
        }

        print("nodes: " + _nodes.Count);

        int nodeCount = _nodes.Count;

        adjacencyMatrix = new int[_nodes.Count * _nodes.Count];

        nodeAcc       = new Vector3[_nodes.Count * _nodes.Count];
        nodeVel       = new Vector3[_nodes.Count];
        nodeAccBuffer = new ComputeBuffer(nodeAcc.Length, 3 * 4);
        nodeVelBuffer = new ComputeBuffer(nodeVel.Length, 3 * 4);

        for (int i = 0; i < nodeAcc.Length; ++i)
        {
            nodeAcc [i]         = new Vector3();
            adjacencyMatrix [i] = new int();
        }

        for (int i = 0; i < nodeVel.Length; ++i)
        {
            nodeVel[i] = new Vector3();
        }



        shaderInput = new NodeDS[_nodes.Count];
        for (int i = 0; i < _nodes.Count; ++i)
        {
            shaderInput[i] = new NodeDS
            {
                pos = _nodes[i].pos,
                acc = new Vector3(),
                vel = _nodes[i].vel
            };
        }
        dataBuffer = new ComputeBuffer(shaderInput.Length, 3 * 4 * 3);
        dataBuffer.SetData(shaderInput);

        shaderEdges = new EdgeDS[_edges.Count];
        for (int i = 0; i < _edges.Count; ++i)
        {
            shaderEdges [i]     = new EdgeDS();
            shaderEdges [i].id1 = _nodes.IndexOf(_edges [i].Body1);
            shaderEdges [i].id2 = _nodes.IndexOf(_edges [i].Body2);
            adjacencyMatrix [nodeCount * shaderEdges [i].id2 + shaderEdges [i].id1] = 1;
        }
        edgeBuffer = new ComputeBuffer(shaderEdges.Length, 4 * 2);
        edgeBuffer.SetData(shaderEdges);

        adjacencyMatrixBuffer = new ComputeBuffer(adjacencyMatrix.Length, 4);
        adjacencyMatrixBuffer.SetData(adjacencyMatrix);

        for (int i = 0; i < nodeCount; ++i)
        {
            shaderInput[i].pos = _nodes[i].pos;
            shaderInput[i].acc = new Vector3();
            shaderInput[i].vel = _nodes[i].vel;
        }
    }