Package edu.ucla.sspace.util.primitive

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


     *
     * @return the set of rows that were selected
     */
    public DoubleVector[] chooseSeeds(Matrix dataPoints, int k, int[] weights) {

        IntSet selected = new TroveIntSet();
        int rows = dataPoints.rows();
        // Edge case for where the user has requested more seeds than are
        // available.  In this case, just return indices for all the rows
        if (rows <= k) {
            DoubleVector[] arr = new DoubleVector[rows];
            for (int i = 0; i < rows; ++i)
                arr[i] = dataPoints.getRowVector(i);
            return arr;
        }

        // This array keeps the relative probability of that index's data point
        // being selected as a centroid.  Although the probabilities change with
        // each center added, the array is only allocated once and is refilled
        // using determineProbabilities() method.
        double[] probabilities = new double[rows];

        // This array keeps the memoized computation of the maximum similarity
        // of each data point i, to any center currently in selected.  After the
        // first two points are selected, each iteration updates this array with
        // the maximum simiarlity of the new center to that point's index.
        double[] inverseSimilarities  = new double[rows];

        // Pick the first two centers, x, y, with probability proportional to
        // 1/sim(x, y).  In the original paper the probility is proportional to
        // ||x - y||^2, which is the square of the distance between the two
        // points.  However, since we use the simiarlity (which is conceptually
        // the inverse of distance), we use the inverse similarity so that
        // elements that are more similarity (i.e., larger values) have smaller
        // probabilities.
  IntPair firstTwoCenters =
            pickFirstTwo(dataPoints, simFunc, weights, inverseSimilarities);
        selected.add(firstTwoCenters.x);
        selected.add(firstTwoCenters.y);

        // For the remaining k-2 points to select, pick a random point, x, with
        // probability min(1/sim(x, c_i)) for all centers c_i in selected.
        // Again, this probability-based selection is updated from the original
        // ORSS paper, which used || x - c_i ||^2 for all centers c.  See the
        // comment above for the reasoning.
  for (int i = 2; i < k; i++) {

            // First, calculate the probabilities for selecting each point given
            // its similarity to any of the currently selected centers
            determineProbabilities(inverseSimilarities, weights, 
                                   probabilities, selected);

            // Then sample a point from the multinomial distribution over the
            // remaining points in dataPoints
            int point = selectWithProb(probabilities);

            // Once we've selected a point, add it the set that we will return
            // and update the similarity all other non-selected points relative
            // to be the highest similarity to any selected point
            boolean added = selected.add(point);
            assert added : "Added duplicate row to the set of selected points";           
            updateNearestCenter(inverseSimilarities, dataPoints,
                                point, simFunc);
  }

        IntIterator iter = selected.iterator();
        DoubleVector[] centroids = new DoubleVector[k];
        for (int i = 0; iter.hasNext(); ++i)
            centroids[i] = dataPoints.getRowVector(iter.nextInt());
        return centroids;
    }
View Full Code Here


    static <E extends Edge> boolean areVerticesContiguous(Graph<E> g) {
        return true;
    }

    static int getMaxClass(int v, int[] vertexAssignments, Graph g) {
        IntSet neighbors = g.getNeighbors(v);
        IntIterator iter = neighbors.iterator();
        Counter<Integer> classes = new ObjectCounter<Integer>();
        classes.count(vertexAssignments[v]);
        while (iter.hasNext()) {
            int n = iter.nextInt();
            classes.count(vertexAssignments[n]);
View Full Code Here

    /**
     * {@inheritDoc}
     */
    public IntSet predecessors(int vertex) {
        IntSet preds = new TroveIntSet();
        for (DirectedEdge e : inEdges(vertex))
            preds.add(e.from());
        return preds;
    }
View Full Code Here

    /**
     * {@inheritDoc}
     */
    public IntSet successors(int vertex) {
        IntSet succs = new TroveIntSet();
        for (DirectedEdge e : outEdges(vertex))
            succs.add(e.to());
        return succs;
    }
View Full Code Here

        /**
         * {@inheritDoc}
         */
        public IntSet predecessors(int vertex) {
            IntSet preds = new TroveIntSet();
            for (DirectedEdge e : inEdges(vertex))
                preds.add(e.from());
            return preds;
        }
View Full Code Here

        /**
         * {@inheritDoc}
         */
        public IntSet successors(int vertex) {
            IntSet succs = new TroveIntSet();
            for (DirectedEdge e : outEdges(vertex))
                succs.add(e.to());
            return succs;
        }
View Full Code Here

        public Extension(int v) {
            this.v = v;
            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);
            }
View Full Code Here

        @Override public IntIterator iterator() {
            return new CombinedIterator();
        }

         @Override public int size() {
             IntSet smaller, larger;
             if (inEdges.size() < outEdges.size()) {
                 smaller = inEdges;
                 larger = outEdges;
             }
             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++;
             }
View Full Code Here

    private void flushBuffer(ByteBuffer buffer, boolean force) throws IOException {
        if (buffer.position()==0) return;
        if (force || buffer.position()==buffer.limit()) {
            buffer.limit(buffer.position());
            buffer.position(0);
            IntSet failedPositions = new TroveIntSet(100);
            long time=System.currentTimeMillis();
            while (buffer.position() != buffer.limit()) {
                final int position = buffer.position();
                if (!updateFromBuffer(buffer)) failedPositions.add(position);
            }
            if (log.isInfoEnabled()) log.info(String.format("flushed buffer %d, kept %d took %d ms.",idx(buffer),failedPositions.size(),System.currentTimeMillis()-time));
            stats[idx(buffer)].written(buffer.position()/RECORD_SIZE - failedPositions.size());
            buffer.limit(capacity);
            int initialPos=failedPositions.isEmpty() ? 0 : copyFailedPositions(buffer, failedPositions);
            buffer.position(initialPos);
        }
    }
View Full Code Here

            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(
View Full Code Here

TOP

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

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.