Package edu.ucla.sspace.util.primitive

Examples of edu.ucla.sspace.util.primitive.IntIterator

83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
            throws IOException {

        PrintWriter pw = new PrintWriter(f);
        pw.println("*Vertices " + g.order());
        if (vertexLabels != null) {
            IntIterator iter = g.vertices().iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                String label = vertexLabels.lookup(v);
                if (label != null)
                    pw.printf("%d \"%s\"%n", v, label);
            }
        }
       
        // We will flatten all the parallel edges together, which requires
        // iterative over the edges to see how many unique compacted edges there
        // are.  We need to know the number for the pajek formatting
        pw.println("*Edges");
        IntIterator iter = g.vertices().iterator();
        while (iter.hasNext()) {
            int v1 = iter.nextInt();
            IntIterator iter2 = g.getNeighbors(v1).iterator();
            while (iter2.hasNext()) {
                int v2 = iter2.nextInt();
                if (v1 < v2)
                    continue;
                Set<? extends WeightedEdge> edges = g.getEdges(v1, v2);
                double fromWeight = 0;
                double toWeight = 0;
View Full Code Here
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
     */
     public CompactSparseTypedEdgeSet<T> copy(IntSet vertices) {       
         CompactSparseTypedEdgeSet<T> copy = new CompactSparseTypedEdgeSet<T>(rootVertex);
        
         if (vertices.size() < edges.size()) {
            IntIterator iter = vertices.iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                if (edges.containsKey(v)) {
                    BitSet b = edges.get(v);
                    BitSet b2 = new BitSet();
                    b2.or(b);
                    copy.edges.put(v, b2);
                }
            }           
        }
        else {
            TIntObjectIterator<BitSet> iter = edges.iterator();
            while (iter.hasNext()) {
                iter.advance();
                int v = iter.key();
                if (vertices.contains(v)) {
                    BitSet b = iter.value();
                    BitSet b2 = new BitSet();
                    b2.or(b);
                    copy.edges.put(v, b2);
                }
            }
View Full Code Here
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
        SparseDirectedTypedEdgeSet<T> copy =
            new SparseDirectedTypedEdgeSet<T>(rootVertex);
        if (vertices.size() < inEdges.size()
                && vertices.size() < outEdges.size()) {

            IntIterator iter = vertices.iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                if (inEdges.containsKey(v))
                    copy.inEdges.put(v, outEdges.get(v));
                if (outEdges.containsKey(v))
                    copy.inEdges.put(v, outEdges.get(v));
            }           
        }
        else {
            TIntObjectIterator<BitSet> iter = inEdges.iterator();
            while (iter.hasNext()) {
                iter.advance();
                int v = iter.key();
                if (vertices.contains(v))
                    copy.inEdges.put(v, iter.value());
            }
            iter = outEdges.iterator();
            while (iter.hasNext()) {
                iter.advance();
                int v = iter.key();
                if (vertices.contains(v))
                    copy.outEdges.put(v, iter.value());
            }
        }
        return copy;
    }
View Full Code Here
211
212
213
214
215
216
217
218
219
220
221
222
223
            vertsInSubgraph = new ArrayDeque<Integer>();
            extensionStack = new ArrayDeque<TIntHashSet>();

            IntSet neighbors = g.getNeighbors(v);
            TIntHashSet extension = new TIntHashSet();
            IntIterator iter = neighbors.iterator();
            while (iter.hasNext()) {
                int u = iter.nextInt();
                if (u > v)
                    extension.add(u);
            }

            vertsInSubgraph.push(v);
View Full Code Here
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
    public SparseDirectedEdgeSet copy(IntSet vertices) {       
        SparseDirectedEdgeSet copy = new SparseDirectedEdgeSet(rootVertex);
        if (vertices.size() < inEdges.size()
                && vertices.size() < outEdges.size()) {

            IntIterator iter = vertices.iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                if (inEdges.contains(v))
                    copy.inEdges.add(v);
                if (outEdges.contains(v))
                    copy.inEdges.add(v);
            }           
        }
        else {
            IntIterator iter = inEdges.iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                if (vertices.contains(v))
                    copy.inEdges.add(v);
            }
            iter = outEdges.iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                if (vertices.contains(v))
                    copy.outEdges.add(v);
            }
        }
        return copy;
View Full Code Here
506
507
508
509
510
511
512
513
514
515
516
517
518
             else {
                 smaller = outEdges;
                 larger = inEdges;
             }
             int size = larger.size();
             IntIterator iter = smaller.iterator();
             while (iter.hasNext()) {
                 int i = iter.nextInt();
                 if (!larger.contains(i))
                     size++;
             }
             return size;
         }
View Full Code Here
127
128
129
130
131
132
133
134
135
136
137
138
139
                if (vertices.contains(v))
                    copy.edges.add(v);
            }           
        }
        else {
            IntIterator iter = vertices.iterator();
            while (iter.hasNext()) {
                int v = iter.nextInt();
                if (edges.contains(v))
                    copy.edges.add(v);
            }
        }
        return copy;
View Full Code Here
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
        edgeIndexer.lookup(0);

        // For each edge, find the most similar cluster updating the relative
        // indices of the rowToMostSimilar arrays with the results.
        Object taskKey = WORK_QUEUE.registerTaskGroup(g.order());
        IntIterator iter1 = g.vertices().iterator();
        while (iter1.hasNext()) {
            final int v1 = iter1.nextInt();
            WORK_QUEUE.add(taskKey, new Runnable() {
                    public void run() {
                        veryVerbose(LOGGER, "Computing similarities for " +
                                    "vertex %d", v1);
                        IntSet neighbors = g.getNeighbors(v1);
                        IntIterator it1 = neighbors.iterator();
                        while (it1.hasNext()) {
                            int v2 = it1.nextInt();
                            IntIterator it2 = neighbors.iterator();
                            while (it2.hasNext()) {
                                int v3 = it2.nextInt();
                                if (v2 == v3)
                                    break;
                                double sim = getConnectionSimilarity(
                                    g, v1, v2, v3);
View Full Code Here
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
        edgeIndexer.lookup(0);

        // For each edge, find the most similar cluster updating the relative
        // indices of the rowToMostSimilar arrays with the results.
        Object taskKey = WORK_QUEUE.registerTaskGroup(g.order());
        IntIterator iter1 = g.vertices().iterator();
        while (iter1.hasNext()) {
            final int v1 = iter1.nextInt();
            WORK_QUEUE.add(taskKey, new Runnable() {
                    public void run() {
                        veryVerbose(LOGGER, "Computing similarities for " +
                                    "vertex %d", v1);
                        IntSet neighbors = g.getNeighbors(v1);
                        IntIterator it1 = neighbors.iterator();
                        while (it1.hasNext()) {
                            int v2 = it1.nextInt();
                            IntIterator it2 = neighbors.iterator();
                            while (it2.hasNext()) {
                                int v3 = it2.nextInt();
                                if (v2 == v3)
                                    break;
                                double sim = getConnectionSimilarity(
                                    g, v1, v2, v3);
                               
View Full Code Here
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
        final PriorityQueue<EdgePair> pq =
            new PriorityQueue<EdgePair>(numComparisons);
        Object key = WORK_QUEUE.registerTaskGroup(graph.order());
       
        IntIterator iter1 = graph.vertices().iterator();
        while (iter1.hasNext()) {
            final int v1 = iter1.nextInt();
            WORK_QUEUE.add(key, new Runnable() {
                    public void run() {
                        veryVerbose(LOGGER, "Computing similarities for " +
                                    "vertex %d", v1);
                        //Set<E> adjList = graph.getAdjacencyList(v1);
                        IntSet neighbors = graph.getNeighbors(v1);
                        // Create a thread-local PriorityQueue that will hold
                        // the edge similarities for this vertex.  Once all the
                        // simialrites have been computed, we can update the
                        // thread-shared queue with minimal locking
                        PriorityQueue<EdgePair> localQ =
                            new PriorityQueue<EdgePair>(neighbors.size());
                        IntIterator it1 = neighbors.iterator();
                        // for (E e1 : adjList) {
                        while (it1.hasNext()) {
                            // int v2 = (e1.to() == v1) ? e1.from() : e1.to();
                            int v2 = it1.nextInt();
                           
                            IntIterator it2 = neighbors.iterator();
                            // for (Edge e2 : graph.getAdjacencyList(v1)) {
                            while (it2.hasNext()) {
                                int v3 = it2.nextInt();
                                if (v2 == v3)
                                    break;
                                // if (e1.equals(e2))
                                //     break;                              
                                // int v3 = (e2.to() == v1) ? e2.from() : e2.to();
View Full Code Here
TOP

Related Classes of edu.ucla.sspace.util.primitive.IntIterator

  • edu.ucla.sspace.clustering.FastStreamingKMeans
  • edu.ucla.sspace.clustering.seeding.GeneralizedOrssSeed
  • edu.ucla.sspace.clustering.Streemer
  • edu.ucla.sspace.graph.BetweennessCentrality
  • edu.ucla.sspace.graph.ChineseWhispersClustering
  • edu.ucla.sspace.graph.CompactSparseTypedEdgeSet
  • edu.ucla.sspace.graph.Graphs
  • edu.ucla.sspace.graph.io.GexfIO
  • edu.ucla.sspace.graph.io.PajekIO
  • edu.ucla.sspace.graph.io.PajekWriter
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.