001    // GraphLab Project: http://graphlab.sharif.edu
002    // Copyright (C) 2008 Mathematical Science Department of Sharif University of Technology
003    // Distributed under the terms of the GNU Lesser General Public License (LGPL): http://www.gnu.org/licenses/
004    
005    /**
006     * TestListGraph.java
007     *
008     * Created on November 15, 2004, 4:30 AM
009     */
010    
011    package graphlab.library.test;
012    
013    import graphlab.library.*;
014    import graphlab.library.algorithms.spanningtree.Kruskal;
015    import graphlab.library.algorithms.subgraphs.InducedSubgraphs;
016    import graphlab.library.algorithms.traversal.BreadthFirstSearch;
017    import graphlab.library.algorithms.traversal.DepthFirstSearch;
018    import graphlab.library.algorithms.util.AcyclicChecker;
019    import graphlab.library.algorithms.util.ConnectivityChecker;
020    import graphlab.library.event.handlers.PreWorkPostWorkHandler;
021    import graphlab.library.genericcloners.BaseEdgeVertexCopier;
022    
023    import java.util.ArrayList;
024    import java.util.Comparator;
025    import java.util.Iterator;
026    import java.util.Vector;
027    
028    /**
029     * @author Omid Aladini
030     */
031    public class TestListGraph {
032    
033        static class SampleTraversalHandler implements PreWorkPostWorkHandler<BaseVertex> {
034            ArrayList<Integer> existanceSet = new ArrayList<Integer>();
035    
036            public boolean doPreWork(BaseVertex fromVertex, BaseVertex toVertex) {
037                System.out.print("->" + toVertex.getId());
038    
039                if (existanceSet.contains(toVertex.getId()))
040                    System.out.println("Oh, double entering!");
041                else
042                    existanceSet.add(toVertex.getId());
043    
044                return false;
045            }
046    
047            public boolean doPostWork(BaseVertex returnFrom, BaseVertex returnTo) {
048                System.out.println("");
049                System.out.print("<-" + returnTo.getId());
050                return false;
051            }
052    
053        }
054    
055        /*
056          * This class is for comparing two edges according to their weights.
057          * @author Omid Aladini
058          */
059        public static class BaseEdgeWeightComparator
060                implements Comparator<BaseEdge<BaseVertex>> {
061            public int compare(BaseEdge<BaseVertex> o1, BaseEdge<BaseVertex> o2) {
062                if (o1.getWeight() < o2.getWeight())
063                    return -1;
064                else if (o1.getWeight() == o2.getWeight())
065                    return 0;
066                else
067                    return 1;
068            }
069        }
070    
071        public static void mainCheckAcyclicChecker(String args[]) {
072            ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph = new ListGraph<BaseVertex, BaseEdge<BaseVertex>>(true, 0);
073            BaseVertex v1 = new BaseVertex();
074            BaseVertex v2 = new BaseVertex();
075            BaseVertex v3 = new BaseVertex();
076            BaseVertex v4 = new BaseVertex();
077            myListGraph.insertVertex(v1);
078            myListGraph.insertVertex(v2);
079            myListGraph.insertVertex(v3);
080            myListGraph.insertVertex(v4);
081    
082            myListGraph.insertEdge(new BaseEdge<BaseVertex>(v1, v2));
083            myListGraph.insertEdge(new BaseEdge<BaseVertex>(v2, v3));
084            myListGraph.insertEdge(new BaseEdge<BaseVertex>(v3, v4));
085            BaseEdge<BaseVertex> e = new BaseEdge<BaseVertex>(v4, v1);
086            myListGraph.insertEdge(e);
087            //myListGraph.removeEdge(e);
088            System.out.println("Acyclic:" + (AcyclicChecker.isGraphAcyclic(myListGraph) ? "yes" : "no"));
089    
090            /*
091              final int iterations = 1000;
092              int acyclic = 0;
093              for(int i =0;i<iterations;++i)
094              {
095                  ListGraph<BaseVertex,BaseEdge<BaseVertex>> myListGraph =
096                      generateRandomListGraph(10,9);
097    
098                  acyclic += AcyclicChecker.isGraphAcyclic(myListGraph)?1:0;
099                  //System.out.println("Graph acyclick: " + isAc);
100                  System.out.println("i:" + i);
101              }
102    
103              System.out.println("Graph acyclic: " + ((double)(acyclic))/(iterations)*100 + "% of times.");
104              */
105        }
106    
107        public static void mainCheckConnectivityChecker(String args[]) {
108            final int iterations = 100000;
109            int connected = 0;
110            for (int i = 0; i < iterations; ++i) {
111                ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph =
112                        generateRandomListGraph(3, 2);
113    
114                connected += ConnectivityChecker.isGraphConnected(myListGraph) == true ? 1 : 0;
115            }
116    
117            System.out.println("Graph connected: " + ((double) (connected)) / (iterations) * 100 + "% of times.");
118        }
119    
120        public static void mainCheckTraversals(String args[]) {
121            ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph =
122                    generateRandomListGraph(30, 100);
123    
124            System.out.println("-------------DFS TEST-----------");
125    
126            new DepthFirstSearch<BaseVertex, BaseEdge<BaseVertex>>(myListGraph)
127                    .doSearch(myListGraph.getAVertex(), new SampleTraversalHandler());
128    
129            for (BaseVertex v : myListGraph)
130                if (!v.getMark())
131                    System.out.println("Oh, one vertex not traversed!");
132    
133            System.out.println("\n-------------BFS TEST-----------");
134    
135            new BreadthFirstSearch<BaseVertex, BaseEdge<BaseVertex>>(myListGraph)
136                    .doSearch(myListGraph.getAVertex(), new SampleTraversalHandler());
137    
138    
139            for (BaseVertex v : myListGraph)
140                if (!v.getMark())
141                    System.out.println("Oh, one vertex not traversed!");
142    
143        }
144    
145        public static ListGraph<BaseVertex, BaseEdge<BaseVertex>>
146        generateRandomListGraph(final int vertexCount, final int edgeCount) {
147            ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph =
148                    new ListGraph<BaseVertex, BaseEdge<BaseVertex>>();
149    
150            Vector<BaseVertex> vbv = new Vector<BaseVertex>();
151    
152            for (int i = 0; i < vertexCount; ++i)
153                vbv.add(new BaseVertex());
154    
155            for (BaseVertex v : vbv)
156                myListGraph.insertVertex(v);
157    
158            java.util.Random r = new java.util.Random(/*109876L*/);
159    
160            for (int i = 0; i < edgeCount; ++i) {
161                int randV1 = Math.abs(r.nextInt()) % vertexCount;
162                int randV2 = Math.abs(r.nextInt()) % vertexCount;
163                myListGraph.insertEdge(new BaseEdge<BaseVertex>(vbv.get(randV1), vbv.get(randV2), new BaseEdgeProperties(0, 0, false)));
164            }
165            return myListGraph;
166        }
167    
168        public static <VertexType extends BaseVertex, EdgeType extends BaseEdge<VertexType>>
169        void
170        setRandomWeights(BaseGraph<VertexType, EdgeType> graph, int limit) {
171            java.util.Random r = new java.util.Random();
172            Iterator<EdgeType> iet = graph.edgeIterator();
173            while (iet.hasNext())
174                iet.next().setWeight(Math.abs(r.nextInt()) % limit);
175        }
176    
177    
178        public static void mainTestVertexInduced(String args[]) {
179            ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph = generateRandomListGraph(30, 100);
180            myListGraph.dump();
181    
182            ArrayList<BaseVertex> arr = new ArrayList<BaseVertex>();
183    
184            for (int i = 0; i < myListGraph.getVerticesCount(); i += 2)
185                arr.add(myListGraph.getVertexArray()[i]);
186    
187            BaseGraph<BaseVertex, BaseEdge<BaseVertex>> vInducedGraph =
188                    InducedSubgraphs.getVertexInducedSubgraph(myListGraph, arr);
189    
190            vInducedGraph.dump();
191        }
192    
193        public static void mainTestEdgeInduced(String args[]) {
194            ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph = generateRandomListGraph(30, 100);
195            myListGraph.dump();
196    
197            ArrayList<BaseEdge<BaseVertex>> arr = new ArrayList<BaseEdge<BaseVertex>>();
198    
199            Iterator<BaseEdge<BaseVertex>> it = myListGraph.edgeIterator();
200            for (int i = 0; i < myListGraph.getEdgesCount(); ++i) {
201                BaseEdge<BaseVertex> e = it.next();
202                if (i % 12 == 0)
203                    arr.add(e);
204            }
205    
206            BaseGraph<BaseVertex, BaseEdge<BaseVertex>> eInducedGraph =
207                    InducedSubgraphs.getEdgeInducedSubgraph(myListGraph, arr);
208    
209            eInducedGraph.dump();
210        }
211    
212        public static void mainOld(String args[]) {
213            try {
214                ListGraph<BaseVertex, BaseEdge<BaseVertex>> myList = new ListGraph<BaseVertex, BaseEdge<BaseVertex>>();
215                BaseVertex v0 = new BaseVertex();
216                BaseVertex v1 = new BaseVertex();
217                BaseVertex v2 = new BaseVertex();
218    
219                myList.insertVertex(v0);
220                myList.insertVertex(v1);
221                myList.insertVertex(v2);
222    
223                myList.insertEdge(new BaseEdge<BaseVertex>(v0, v1, new BaseEdgeProperties(0, 5, false)));
224                myList.insertEdge(new BaseEdge<BaseVertex>(v1, v2, new BaseEdgeProperties(0, 10, false)));
225                myList.insertEdge(new BaseEdge<BaseVertex>(v2, v0, new BaseEdgeProperties(0, 2, false)));
226                myList.dump();
227    
228                BaseVertex v3 = new BaseVertex();
229    
230                myList.insertVertex(v3);
231                myList.insertEdge(new BaseEdge<BaseVertex>(v2, v3, new BaseEdgeProperties(0, 1, false)));
232                myList.insertEdge(new BaseEdge<BaseVertex>(v0, v1, new BaseEdgeProperties(0, 20, false)));
233                System.out.println("||---");
234                myList.dump();
235                System.out.println("||---");
236                myList.copy(new BaseEdgeVertexCopier()).dump();
237                System.out.println("TestMatrixGraph graph traversal");
238                System.out.println("\nDFS");
239    
240                BaseVertex v = myList.getAVertex();
241    
242                Iterator<BaseEdge<BaseVertex>> eIterator = myList.edgeIterator();
243                System.out.print('\n');
244                while (eIterator.hasNext()) {
245                    BaseEdge e = eIterator.next();
246                    System.out.println("An Edge from:" + e.source.getId() + " to:" + e.target.getId());
247                }
248    
249                System.out.println("\nPrim Algorithm on this graph:");
250                myList.dump();
251                //prim output has been changed
252                //                  new Prim<BaseVertex,BaseEdge<BaseVertex>>(myList, new BaseEdgeVertexGraphConverter()).
253                //                                  findMinimumSpanningTree(myList.getAVertex(),new BaseEdgeWeightComparator()).dump();
254    
255                //System.out.println("\nRemoving a vertex " + myList.getVerticesCount());
256                //myList.removeVertex(v);
257    
258                System.out.println("\nBefore traversal");
259                new DepthFirstSearch<BaseVertex, BaseEdge<BaseVertex>>(myList).doSearch(v, new SampleTraversalHandler());
260                new BreadthFirstSearch<BaseVertex, BaseEdge<BaseVertex>>(myList).doSearch(v, new SampleTraversalHandler());
261    
262            } catch (Exception e) {
263                System.out.println("Noooooo:");
264                e.printStackTrace();
265            }
266        }
267    
268        public static void mainTestKruskal(String args[]) {
269            ListGraph<BaseVertex, BaseEdge<BaseVertex>> l = new ListGraph<BaseVertex, BaseEdge<BaseVertex>>();
270            ListGraph<BaseVertex, BaseEdge<BaseVertex>> f = l.createEmptyGraph();
271            final int iterations = 100;
272            for (int i = 0; i < iterations; ++i) {
273                ListGraph<BaseVertex, BaseEdge<BaseVertex>> myListGraph =
274                        generateRandomListGraph(50, 90);
275                setRandomWeights(myListGraph, 20);
276                int count = Kruskal.findMinimumSpanningTree(myListGraph).size();
277                System.out.println("Size of spanning tree:" + count);
278            }
279    
280        }
281    
282        public static void main/*TestLightEdgeIterator*/(String args[]) {
283            ListGraph<BaseVertex, BaseEdge<BaseVertex>> g
284                    = new ListGraph<BaseVertex, BaseEdge<BaseVertex>>(false, 3);
285            BaseVertex v[] = new BaseVertex[3];
286            for (int i = 0; i < 3; i++) {
287                v[i] = new BaseVertex();
288                g.insertVertex(v[i]);
289            }
290            g.insertEdge(new BaseEdge<BaseVertex>(v[1], v[0]));
291            g.insertEdge(new BaseEdge<BaseVertex>(v[2], v[1]));
292            Iterator<BaseEdge<BaseVertex>> ie = g.lightEdgeIterator(v[1]);
293            while (ie.hasNext()) {
294                System.out.println(ie.next());
295            }
296            System.out.println("**");
297            for (BaseVertex vv : g.getNeighbors(v[1]))
298                System.out.println(vv);
299        }
300    
301    }