Example usage for org.apache.commons.collections15.functors MapTransformer getInstance

List of usage examples for org.apache.commons.collections15.functors MapTransformer getInstance

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections15.functors.*
  5. MapTransformer
  6. getInstance

Introduction

In this page you can find the example usage for org.apache.commons.collections15.functors MapTransformer getInstance.

Prototype

public static <I, O> Transformer<I, O> getInstance(Map<I, O> map)

Source Link

Document

Factory to create the transformer.

Usage

From source file:edu.uci.ics.jung.algorithms.scoring.TestPageRank.java

public void testRanker() {
    graph = new DirectedSparseMultigraph<Integer, Integer>();
    for (int i = 0; i < 4; i++) {
        graph.addVertex(i);//from w w w. j  av  a  2  s  . c  o m
    }
    addEdge(graph, 0, 1, 1.0);
    addEdge(graph, 1, 2, 1.0);
    addEdge(graph, 2, 3, 0.5);
    addEdge(graph, 3, 1, 1.0);
    addEdge(graph, 2, 1, 0.5);

    PageRankWithPriors<Integer, Integer> pr = new PageRank<Integer, Integer>(graph,
            MapTransformer.getInstance(edgeWeights), 0);
    pr.evaluate();

    Assert.assertEquals(pr.getVertexScore(0), 0.0, pr.getTolerance());
    Assert.assertEquals(pr.getVertexScore(1), 0.4, pr.getTolerance());
    Assert.assertEquals(pr.getVertexScore(2), 0.4, pr.getTolerance());
    Assert.assertEquals(pr.getVertexScore(3), 0.2, pr.getTolerance());

    //        Assert.assertTrue(NumericalPrecision.equal(((Ranking)ranker.getRankings().get(0)).rankScore,0.4,.001));
    //        Assert.assertTrue(NumericalPrecision.equal(((Ranking)ranker.getRankings().get(1)).rankScore,0.4,.001));
    //        Assert.assertTrue(NumericalPrecision.equal(((Ranking)ranker.getRankings().get(2)).rankScore,0.2,.001));
    //        Assert.assertTrue(NumericalPrecision.equal(((Ranking)ranker.getRankings().get(3)).rankScore,0,.001));
}

From source file:edu.uci.ics.jung.algorithms.importance.MarkovCentrality.java

/**
 * Loads the stationary distribution into a vector if it was passed in,
 * or calculates it if not.//from   www .j a v  a2s. c om
 *
 * @return DoubleMatrix1D
 */
private DoubleMatrix1D getStationaryDistribution() {
    DoubleMatrix1D piVector = new DenseDoubleMatrix1D(getVertexCount());
    PageRank<V, E> pageRank = new PageRank<V, E>(getGraph(), MapTransformer.getInstance(getEdgeWeights()), 0);
    pageRank.evaluate();

    for (V v : getGraph().getVertices())
        piVector.set(mIndexer.get(v), pageRank.getVertexScore(v));
    return piVector;
}

From source file:edu.uci.ics.jung.algorithms.transformation.VertexPartitionCollapser.java

/**
 * Returns a transformer from vertex sets in the original graph to collapsed vertices
 * in the transformed graph.//from  w ww  .j av  a 2s . co m
 */
public Transformer<Set<V>, CV> getSetToCollapsedVertexTransformer() {
    return MapTransformer.getInstance(set_collapsedv);
}

From source file:mulavito.algorithms.shortestpath.disjoint.SuurballeTarjan.java

/**
 * The heart of the SuurballeTarjan algorithm.
 * /*  ww w  . j ava 2s  . c  o m*/
 * @param source
 *            the source node
 * @param target
 *            the target node
 * @return two disjoint paths from the source to target node.
 */
public List<List<E>> getDisjointPaths(V source, V target) {
    if (dijkstra.getDistance(source, target) == null)
        return null; // target is not reachable!

    List<E> sp = dijkstra.getPath(source, target);

    // Determine length of shortest path from "source" to any other node.
    Map<V, Number> lengthMap = dijkstra.getDistanceMap(source);

    // Length transformation.
    Transformer<E, Double> lengthTrans = lengthTransformation(graph, MapTransformer.getInstance(lengthMap));

    // Get shortest path in g with reversed shortest path...
    Graph<V, E> revG = reverseEdges(graph, sp);
    DijkstraShortestPath<V, E> revDijkstra = new DijkstraShortestPath<V, E>(revG, lengthTrans);

    if (revDijkstra.getDistance(source, target) == null) {
        // no alternate path
        List<List<E>> result = new LinkedList<List<E>>();
        result.add(sp);
        return result;
    }

    List<E> revSp = revDijkstra.getPath(source, target);

    validate(source, target, sp, graph);
    validate(source, target, revSp, revG);

    LinkedList<E> spCopy = new LinkedList<E>(sp);

    List<List<E>> paths = findTwoWays(sp, revSp);

    if (paths == null) {
        // no disjoint solution found, just return shortest path
        LinkedList<List<E>> result = new LinkedList<List<E>>();
        result.add(spCopy);
        return result;
    }

    // Check path validity.
    for (List<E> path : paths)
        validate(source, target, path, graph);

    return paths;
}

From source file:mulavito.algorithms.shortestpath.ksp.Eppstein.java

/**
 * Create <math>\delta(e)</math> for each edge in graph {@link #g}.
 * /*from   w  w  w.j a  v  a  2 s .c o m*/
 * @param target
 *            The target
 * @return The delta edge weight.
 */
private Transformer<E, Double> prepareTransformations(V target) {
    Map<V, Double> lengthMap = new HashMap<V, Double>(); // d(x, t)
    Map<E, Double> edgeMap = new HashMap<E, Double>();

    // Search the shortest path from "target" to any vertex,
    // and store the length in a map.
    for (V v : graph.getVertices()) {
        Number dist = dijkstra.getDistance(v, target);

        if (dist != null) // target is reachable from v.
            lengthMap.put(v, dist.doubleValue());
        else {
            // Block edges from or to unreachable vertices.
            for (E e : graph.getIncidentEdges(v))
                edgeMap.put(e, Double.POSITIVE_INFINITY);
        }
    }

    // Calculate delta(e)
    for (E e : graph.getEdges()) {
        if (edgeMap.get(e) == null) {
            // Only consider edges to reachable vertices.
            double l = nev.transform(e).doubleValue() /* l(e) */
                    + lengthMap.get(graph.getDest(e)) /* d(head(e), t) */
                    - lengthMap.get(graph.getSource(e)) /* d(tail(e), t) */;
            edgeMap.put(e, l);
        }
    }

    return MapTransformer.getInstance(edgeMap);
}

From source file:mulavito.algorithms.shortestpath.disjoint.SuurballeTarjan.java

/**
 * This method does the following length transformation:
 * /* ww  w  .  j  a v  a2  s .c  o m*/
 * <pre>
 *  c'(v,w) = c(v,w) - d (s,w) + d (s,v)
 * </pre>
 * 
 * @param graph1
 *            the graph
 * @param slTrans
 *            The shortest length transformer
 * @return the transformed graph
 */
private Transformer<E, Double> lengthTransformation(Graph<V, E> graph1, Transformer<V, Number> slTrans) {
    Map<E, Double> map = new HashMap<E, Double>();

    for (E link : graph1.getEdges()) {
        double newWeight = nev.transform(link).doubleValue()
                - slTrans.transform(graph1.getDest(link)).doubleValue()
                + slTrans.transform(graph1.getSource(link)).doubleValue();
        newWeight = MiscelFunctions.roundToDecimals(newWeight, 3); //because it exists -1.....E-18

        map.put(link, newWeight);
    }
    return MapTransformer.getInstance(map);
}

From source file:edu.uci.ics.jung.io.PajekNetIOTest.java

public void testMixedSaveLoadSave() throws IOException {
    Graph<Number, Number> graph1 = new SparseMultigraph<Number, Number>();
    for (int i = 0; i < 5; i++) {
        graph1.addVertex(i);/*  ww  w. ja v a 2s .c  o m*/
    }
    int j = 0;

    List<Number> id = new ArrayList<Number>(graph1.getVertices());//Indexer.getIndexer(graph1);
    GreekLabels<Number> gl = new GreekLabels<Number>(id);
    Number[] edges = { 0, 1, 2, 3, 4, 5 };

    graph1.addEdge(j++, 0, 1, EdgeType.DIRECTED);
    graph1.addEdge(j++, 0, 2, EdgeType.DIRECTED);
    graph1.addEdge(j++, 1, 2, EdgeType.DIRECTED);
    graph1.addEdge(j++, 1, 3);
    graph1.addEdge(j++, 1, 4);
    graph1.addEdge(j++, 4, 3);

    Map<Number, Number> nr = new HashMap<Number, Number>();
    for (int i = 0; i < edges.length; i++) {
        nr.put(edges[i], new Float(Math.random()));
    }

    assertEquals(graph1.getEdgeCount(), 6);

    //        System.err.println(" mixed graph1 = "+graph1);
    //        for(Number edge : graph1.getEdges()) {
    //           System.err.println("edge "+edge+" is directed? "+graph1.getEdgeType(edge));
    //        }
    //        for(Number v : graph1.getVertices()) {
    //           System.err.println(v+" outedges are "+graph1.getOutEdges(v));
    //           System.err.println(v+" inedges are "+graph1.getInEdges(v));
    //           System.err.println(v+" incidentedges are "+graph1.getIncidentEdges(v));
    //        }

    String testFilename = "mtest.net";
    String testFilename2 = testFilename + "2";

    // lay out network
    Dimension d = new Dimension(100, 200);
    Transformer<Number, Point2D> vld = TransformerUtils.mapTransformer(
            LazyMap.decorate(new HashMap<Number, Point2D>(), new RandomLocationTransformer<Number>(d)));

    PajekNetWriter<Number, Number> pnw = new PajekNetWriter<Number, Number>();
    pnw.save(graph1, testFilename, gl, MapTransformer.getInstance(nr), vld);

    Graph<Number, Number> graph2 = pnr.load(testFilename, graphFactory);
    Transformer<Number, String> pl = pnr.getVertexLabeller();
    List<Number> id2 = new ArrayList<Number>(graph2.getVertices());
    Transformer<Number, Point2D> vld2 = pnr.getVertexLocationTransformer();

    assertEquals(graph1.getVertexCount(), graph2.getVertexCount());
    assertEquals(graph1.getEdgeCount(), graph2.getEdgeCount());

    // test vertex labels and locations
    for (int i = 0; i < graph1.getVertexCount(); i++) {
        Number v1 = id.get(i);
        Number v2 = id2.get(i);
        assertEquals(gl.transform(v1), pl.transform(v2));
        assertEquals(vld.transform(v1), vld2.transform(v2));
    }

    // test edge weights
    Transformer<Number, Number> nr2 = pnr.getEdgeWeightTransformer();
    for (Number e2 : graph2.getEdges()) {
        Pair<Number> endpoints = graph2.getEndpoints(e2);
        Number v1_2 = endpoints.getFirst();
        Number v2_2 = endpoints.getSecond();
        Number v1_1 = id.get(id2.indexOf(v1_2));
        Number v2_1 = id.get(id2.indexOf(v2_2));
        Number e1 = graph1.findEdge(v1_1, v2_1);
        assertNotNull(e1);
        assertEquals(nr.get(e1).floatValue(), nr2.transform(e2).floatValue(), 0.0001);
    }

    pnw.save(graph2, testFilename2, pl, nr2, vld2);

    compareIndexedGraphs(graph1, graph2);

    pnr.setVertexLabeller(null);
    Graph<Number, Number> graph3 = pnr.load(testFilename2, graphFactory);

    compareIndexedGraphs(graph2, graph3);

    File file1 = new File(testFilename);
    File file2 = new File(testFilename2);

    Assert.assertTrue(file1.length() == file2.length());
    file1.delete();
    file2.delete();

}

From source file:com.google.code.facebook.graph.sna.applet.PluggableRendererDemo.java

/**
 * Generates a mixed-mode random graph, runs VoltageRanker on it, and
 * returns the resultant graph.//from  w  ww  .ja va 2s . c  o  m
 */
public Graph<Integer, Number> getGraph() {
    Factory<Graph<Integer, Number>> graphFactory = new Factory<Graph<Integer, Number>>() {
        public Graph<Integer, Number> create() {
            return new SparseMultigraph<Integer, Number>();
        }
    };
    Factory<Integer> vertexFactory = new Factory<Integer>() {
        int count;

        public Integer create() {
            return count++;
        }
    };
    Factory<Number> edgeFactory = new Factory<Number>() {
        int count;

        public Number create() {
            return count++;
        }
    };
    Graph<Integer, Number> g = MixedRandomGraphGenerator.<Integer, Number>generateMixedRandomGraph(graphFactory,
            vertexFactory, edgeFactory, edge_weight, 20, false, seedVertices);
    es = new NumberFormattingTransformer<Number>(MapTransformer.getInstance(edge_weight));

    // collect the seeds used to define the random graph

    if (seedVertices.size() < 2)
        System.out.println("need at least 2 seeds (one source, one sink)");

    // use these seeds as source and sink vertices, run VoltageRanker
    boolean source = true;
    Set<Integer> sources = new HashSet<Integer>();
    Set<Integer> sinks = new HashSet<Integer>();
    for (Integer v : seedVertices) {
        if (source)
            sources.add(v);
        else
            sinks.add(v);
        source = !source;
    }
    VoltageScorer<Integer, Number> voltage_scores = new VoltageScorer<Integer, Number>(g,
            MapTransformer.getInstance(edge_weight), sources, sinks);
    voltage_scores.evaluate();
    voltages = new VertexScoreTransformer<Integer, Double>(voltage_scores);
    vs = new NumberFormattingTransformer<Integer>(voltages);

    Collection<Integer> verts = g.getVertices();

    // assign a transparency value of 0.9 to all vertices
    for (Integer v : verts) {
        transparency.put(v, new Double(0.9));
    }

    // add a couple of self-loops (sanity check on rendering)
    Integer v = verts.iterator().next();
    Number e = new Float(Math.random());
    edge_weight.put(e, e);
    g.addEdge(e, v, v);
    e = new Float(Math.random());
    edge_weight.put(e, e);
    g.addEdge(e, v, v);
    return g;
}

From source file:de.unikassel.jung.PluggableRendererDemo.java

/**
 * Generates a mixed-mode random graph, runs VoltageRanker on it, and returns the resultant graph.
 *///from  w w  w . j ava 2s.co m
public Graph<Integer, Number> getGraph() {
    Factory<Graph<Integer, Number>> graphFactory = new Factory<Graph<Integer, Number>>() {
        @Override
        public Graph<Integer, Number> create() {
            return new SparseMultigraph<Integer, Number>();
        }
    };
    Factory<Integer> vertexFactory = new Factory<Integer>() {
        int count;

        @Override
        public Integer create() {
            return count++;
        }
    };
    Factory<Number> edgeFactory = new Factory<Number>() {
        int count;

        @Override
        public Number create() {
            return count++;
        }
    };
    Graph<Integer, Number> g = MixedRandomGraphGenerator.<Integer, Number>generateMixedRandomGraph(graphFactory,
            vertexFactory, edgeFactory, edge_weight, 20, false, seedVertices);
    es = new NumberFormattingTransformer<Number>(MapTransformer.getInstance(edge_weight));

    // collect the seeds used to define the random graph

    if (seedVertices.size() < 2) {
        System.out.println("need at least 2 seeds (one source, one sink)");
    }

    // use these seeds as source and sink vertices, run VoltageRanker
    boolean source = true;
    Set<Integer> sources = new HashSet<Integer>();
    Set<Integer> sinks = new HashSet<Integer>();
    for (Integer v : seedVertices) {
        if (source) {
            sources.add(v);
        } else {
            sinks.add(v);
        }
        source = !source;
    }
    VoltageScorer<Integer, Number> voltage_scores = new VoltageScorer<Integer, Number>(g,
            MapTransformer.getInstance(edge_weight), sources, sinks);
    voltage_scores.evaluate();
    voltages = new VertexScoreTransformer<Integer, Double>(voltage_scores);
    vs = new NumberFormattingTransformer<Integer>(voltages);

    Collection<Integer> verts = g.getVertices();

    // assign a transparency value of 0.9 to all vertices
    for (Integer v : verts) {
        transparency.put(v, new Double(0.9));
    }

    // add a couple of self-loops (sanity check on rendering)
    Integer v = verts.iterator().next();
    Number e = new Float(Math.random());
    edge_weight.put(e, e);
    g.addEdge(e, v, v);
    e = new Float(Math.random());
    edge_weight.put(e, e);
    g.addEdge(e, v, v);
    return g;
}

From source file:org.opendaylight.nic.of.renderer.algorithm.SuurballeAlgorithm.java

public final List<List<E>> findShortestPath(final V initial, final V destination) {
    final List<E> shortestPath = dijkstraAlgorithm.getPath(initial, destination);
    initialCostMap = dijkstraAlgorithm.getDistanceMap(initial);

    final List<E> reversedShortestPath = reverseUpdateEdgesWeight(graph,
            MapTransformer.getInstance(initialCostMap), shortestPath, initial, destination);

    discardCommonReversedEdges(graph, shortestPath, reversedShortestPath);

    final List<E> unitedPaths = ListUtils.union(shortestPath, reversedShortestPath);
    final List<E> resultPath1 = restorePaths(shortestPath, destination, unitedPaths);
    final List<E> resultPath2 = restorePaths(reversedShortestPath, destination, unitedPaths);
    List<List<E>> result = mergePaths(resultPath1, resultPath2);

    if ((result == null) || (result.size() == 0)) {
        result = new ArrayList<>();
        result.add(shortestPath);// w  w w.j av a2s.c  om
    }
    return result;
}