Examples of ptolemy.graph.Node

ptolemy.graph.Node
An optionally-weighted node for an undirected or directed graph. More specifically, a node consists of an optional weight (an arbitrary object that is associated with the node). We say that a node is unweighted if it does not have an assigned weight. It is an error to attempt to access the weight of an unweighted node. Node weights must be genuine (non-null) objects. @author Shuvra S. Bhattacharyya @version $Id: Node.java,v 1.34 2006/03/29 00:02:41 cxh Exp $ @since Ptolemy II 2.0 @Pt.ProposedRating Red (cxh) @Pt.AcceptedRating Red (cxh) @see ptolemy.graph.Edge

            Object entity = actors.next();


            if (entity instanceof AtomicActor
                    || entity instanceof CompositeActor) {
                Actor actor = (Actor) entity;
                Node newNode = graph.addNodeWeight(_computeNodeWeight(actor));
                _actorMap.put(actor, newNode);
                _processNewNode(graph, newNode, actor);
            } else {
                throw new RuntimeException("Unsupported deep entity type: "
                        + entity.getClass().getName() + " (value = " + entity

View Full Code Here

     */
    public List path(Node endNode) {
        int[] predecessors = predecessors();
        ArrayList pathNodes = new ArrayList();
        int predecessorsIndex = predecessors[graph().nodeLabel(endNode)];
        Node predecessor = null;


        if ((predecessorsIndex != -1)) {
            predecessor = graph().node(predecessorsIndex);


            do {

View Full Code Here

        //HashMap color = new HashMap();
        double[] distance = new double[graph.nodeCount()];
        _predecessor = new int[graph.nodeCount()];


        for (Iterator nodes = graph.nodes().iterator(); nodes.hasNext();) {
            Node node = (Node) nodes.next();


            if (node != _startNode) {
                //color.put(node, Color.white);
                distance[graph.nodeLabel(node)] = -Double.MIN_VALUE;
                _predecessor[graph.nodeLabel(node)] = -1;
            } else {
                distance[graph.nodeLabel(node)] = 0.0;
            }
        }


        queue.add(_startNode);
        _predecessor[graph.nodeLabel(_startNode)] = -1;


        while (!queue.isEmpty()) {
            Node u = (Node) queue.get(0);
            Collection successors = graph.successors(u);


            if (successors != null) {
                for (Iterator successorNodes = successors.iterator(); successorNodes
                        .hasNext();) {
                    Node v = (Node) successorNodes.next();
                    double predecessorDistance = distance[graph().nodeLabel(u)];
                    double actualDistance = distance[graph().nodeLabel(v)];
                    Collection edgeCollection = graph.predecessorEdges(v, u);
                    Iterator edges = edgeCollection.iterator();
                    double connectingEdgeCost = -Double.MAX_VALUE;

View Full Code Here

    private double _computeMCMOfSCC(DirectedGraph directedCyclicGraph) {
        _nodesOnCycle.clear();


        // Head
        int n = directedCyclicGraph.nodeCount();
        Node resultNode = null;
        HashMap[] maximumPathLength = new HashMap[n + 1];
        HashMap[] predecessor = new HashMap[n + 1];
        HashMap cycleMean = new HashMap(n);
        HashMap cycleMeanLevel = new HashMap(n);
        double result = -Double.MAX_VALUE;
        Node startingNode = directedCyclicGraph.node(0);
        Collection nodeCollection = directedCyclicGraph.nodes();


        for (int k = 0; k <= n; k++) {
            maximumPathLength[k] = new HashMap(n);
            predecessor[k] = new HashMap(n);


            Iterator nodes = nodeCollection.iterator();


            while (nodes.hasNext()) {
                Node node = (Node) nodes.next();
                maximumPathLength[k].put(node, Double
                        .valueOf(-Double.MAX_VALUE));
            }
        }


        maximumPathLength[0].put(startingNode, Double.valueOf(0));
        predecessor[0].put(startingNode, null);


        // Body
        for (int k = 1; k <= n; k++) {
            Iterator nodes = nodeCollection.iterator();


            while (nodes.hasNext()) {
                Node node = (Node) nodes.next();
                Collection predecessorCollection = directedCyclicGraph
                        .predecessors(node);
                Iterator predecessors = predecessorCollection.iterator();


                while (predecessors.hasNext()) {
                    Node nodePredecessor = (Node) predecessors.next();
                    double dKOfV = ((Double) maximumPathLength[k].get(node))
                            .doubleValue();
                    double dKMinusOneU = ((Double) maximumPathLength[k - 1]
                            .get(nodePredecessor)).doubleValue();
                    double distance = _getCost(nodePredecessor, node);
                    double cost = dKMinusOneU + distance;


                    if (dKOfV < cost) {
                        predecessor[k].put(node, nodePredecessor);
                        maximumPathLength[k].put(node, Double.valueOf(cost));
                    }
                }
            }
        }


        // Tail
        Iterator nodes = nodeCollection.iterator();


        while (nodes.hasNext()) {
            Node node = (Node) nodes.next();
            cycleMean.put(node, Double.valueOf(Double.MAX_VALUE));


            for (int k = 0; k < n; k++) {
                double maximumPathLengthToLevelK = ((Double) maximumPathLength[k]
                        .get(node)).doubleValue();
                double maximumPathLengthToLevelN = ((Double) maximumPathLength[n]
                        .get(node)).doubleValue();
                double cycleMeanValue = ((Double) (cycleMean.get(node)))
                        .doubleValue();
                double testValue = ((maximumPathLengthToLevelN - maximumPathLengthToLevelK) / (n - k));


                if (cycleMeanValue > testValue) {
                    cycleMean.put(node, Double.valueOf(testValue));
                    cycleMeanLevel.put(node, Integer.valueOf(k));
                }
            }


            double cycleMeanValue = ((Double) (cycleMean.get(node)))
                    .doubleValue();


            if (result < cycleMeanValue) {
                result = cycleMeanValue;
                resultNode = node;
            }
        }


        // _dumpVariable(maximumPathLength, directedCyclicGraph);
        //int lambdaCycleMeanLevel = ((Integer) cycleMeanLevel.get(resultNode))
        //        .intValue();
        Node firstNode = resultNode;
        Node secondNode = firstNode;
        int firstNodeLevel = 0;
        int secondNodeLevel = 0;


        for (int i = n; i > 0; i--) {
            for (int j = i; j > 0; j--) {

View Full Code Here


        // create new nodes for the mirror
        Iterator nodes = graph().nodes().iterator();


        while (nodes.hasNext()) {
            Node node = (Node) nodes.next();
            Node mirrorNode = null;


            if (!node.hasWeight()) {
                mirrorNode = new Node();
            } else {
                Object mirrorWeight = null;


                try {
                    // Clone weights of any type of object.
                    if (_cloneWeights) {
                        Object oldWeight = node.getWeight();


                        if (oldWeight instanceof Cloneable) {
                            /* Since clone() of Object is protected, it can't
                             be called publicly. The class Method is used
                             here to call public clone(). */
                            Class[] argumentTypes = {};
                            Method method = oldWeight.getClass().getMethod(
                                    nameClone, argumentTypes);


                            // Cast to (Object []) so as to avoid varargs call.
                            mirrorWeight = method.invoke(oldWeight,
                                    (Object[]) null);
                        } else {
                            throw new RuntimeException();
                        }
                    } else {
                        mirrorWeight = node.getWeight();
                    }
                } catch (Throwable throwable) {
                    /* Exception due to non-Cloneable weights or
                     weights without public clone(). */
                    throw new AnalysisException(
                            "Can not clone the node weight.\n", throwable);
                }


                mirrorNode = new Node(mirrorWeight);
            }


            mirrorGraph.addNode(mirrorNode);
            _originalVersion.put(mirrorNode, node);
            _transformedVersion.put(node, mirrorNode);
        }


        // create new edges for the mirror
        Iterator edges = graph().edges().iterator();


        while (edges.hasNext()) {
            Edge edge = (Edge) edges.next();
            Edge mirrorEdge = null;
            Node mirrorSource = (Node) _transformedVersion.get(edge.source());
            Node mirrorSink = (Node) _transformedVersion.get(edge.sink());


            if (!edge.hasWeight()) {
                mirrorEdge = new Edge(mirrorSource, mirrorSink);
            } else {
                Object mirrorWeight = null;

View Full Code Here

        Object[] edges = graphPlusDelaysAsNodes.edges().toArray();
        HashMap edgeProfitsMap = new HashMap();


        for (int j = 0; j < edges.length; j++) {
            Edge edge = (Edge) edges[j];
            Node source = edge.source();
            Node sink = edge.sink();


            //_edgeCostsMap.put(edge, _edgeCosts.toInt());
            // For all the edges that have at least one delay
            if (_edgeCosts.toInt(edge) != 0) {
                graphPlusDelaysAsNodes.removeEdge(edge);


                int delays = _edgeCosts.toInt(edge);


                for (int i = 0; i < delays; i++) {
                    Node addedNode = graphPlusDelaysAsNodes.addNodeWeight("D"
                            + j + i);
                    _delayNodeList.add(addedNode);


                    Edge addedEdge = graphPlusDelaysAsNodes.addEdge(source,
                            addedNode);
                    edgeProfitsMap.put(addedEdge, Double.valueOf(0.0));
                    source = addedNode;
                }


                Edge lastAddedEdge = graphPlusDelaysAsNodes.addEdge(source,
                        sink);
                edgeProfitsMap.put(lastAddedEdge, Double.valueOf(_edgeProfits
                        .toDouble(edge)));
            } else {
                edgeProfitsMap.put(edge, Double.valueOf(_edgeProfits
                        .toDouble(edge)));
            }
        }


        HashMap D = new HashMap(_delayNodeList.size());
        edges = graphPlusDelaysAsNodes.edges().toArray();


        // compute the first order longest path matrix
        HashMap predecessorMap = new HashMap();


        for (Iterator delayNodes = _delayNodeList.iterator(); delayNodes
                .hasNext();) {
            Node delayNode = (Node) delayNodes.next();
            DirectedGraph thisRoundGraph = (DirectedGraph) graphPlusDelaysAsNodes
                    .clone();
            HashMap delayGraphProfitMap = new HashMap();


            for (int j = 0; j < edges.length; j++) {
                Edge edge = (Edge) edges[j];
                Node source = edge.source();
                Node sink = edge.sink();


                if (sink == delayNode) {
                    predecessorMap.put(delayNode, source);
                }


                if (_delayNodeList.contains(source)
                        || _delayNodeList.contains(sink)) {
                    if (source == delayNode) {
                        delayGraphProfitMap.put(edge, edgeProfitsMap.get(edge));
                    }


                    if (sink == delayNode) {
                        thisRoundGraph.removeEdge(edge);
                    }


                    if ((source != delayNode) && (sink != delayNode)) {
                        if (_delayNodeList.contains(source)) {
                            thisRoundGraph.removeEdge(edge);
                        } else {
                            delayGraphProfitMap.put(edge, edgeProfitsMap
                                    .get(edge));
                        }
                    }
                } else {
                    delayGraphProfitMap.put(edge, edgeProfitsMap.get(edge));
                }
            }


            SingleSourceLongestPathAnalysis longestPath = null;
            longestPath = new SingleSourceLongestPathAnalysis(thisRoundGraph,
                    delayNode, new ToDoubleMapMapping(delayGraphProfitMap));
            D.put(delayNode, longestPath);
        }


        _makeFirstOrderLongestPathMatrix(D, graphPlusDelaysAsNodes,
                predecessorMap);


        // create the delay graph on which the maximum cycle mean is going to
        // be executed.
        DirectedGraph delayGraph = new DirectedGraph();
        HashMap delayGraphEdgeProfits = new HashMap();


        for (int i = 0; i < _delayNodeList.size(); i++) {
            delayGraph.addNode((Node) _delayNodeList.get(i));
        }


        for (int i = 0; i < _delayNodeList.size(); i++) {
            for (int j = 0; j < _delayNodeList.size(); j++) {
                Node source = (Node) _delayNodeList.get(i);
                Node sink = (Node) _delayNodeList.get(j);


                if (_firstOrderLongestPathMatrix[i][j] >= 0) {
                    if (!((source == sink) && (_firstOrderLongestPathMatrix[i][j] == 0))) {
                        Edge addedEdge = delayGraph.addEdge(source, sink);
                        delayGraphEdgeProfits.put(addedEdge, Double
                                .valueOf(_firstOrderLongestPathMatrix[i][j]));
                    }
                }
            }
        }


        double result = _computeMCM(delayGraph, new ToDoubleMapMapping(
                delayGraphEdgeProfits));


        // creating the cycle that leads to the result
        edges = graphPlusDelaysAsNodes.edges().toArray();


        Object[] delayNodes = _delayCycle.toArray();


        for (int i = 0; i < delayNodes.length; i++) {
            Node delayNode = (Node) delayNodes[i];


            for (int j = 0; j < delayNodes.length; j++) {
                if ((i != j) || (delayNodes.length != 1)) {
                    Node endDelayNode = (Node) delayNodes[j];
                    List path = ((SingleSourceLongestPathAnalysis) (D
                            .get(delayNode))).path(endDelayNode);


                    for (int k = 0; k < path.size(); k++) {
                        if (!(_delayNodeList.contains(path.get(k)))) {
                            _maximumProfitToCostRatioCycle.add(path.get(k));
                        }
                    }
                } else if (delayNodes.length == 1) {
                    Node predecessor = (Node) (predecessorMap.get(delayNode));


                    if (!(_delayNodeList.contains(predecessor))) {
                        List path = ((SingleSourceLongestPathAnalysis) (D
                                .get(delayNode))).path(predecessor);

View Full Code Here

        _firstOrderLongestPathMatrix = new double[_delayNodeList.size()][_delayNodeList
                .size()];


        for (int i = 0; i < _delayNodeList.size(); i++) {
            for (int j = 0; j < _delayNodeList.size(); j++) {
                Node column = (Node) _delayNodeList.get(i);
                Node row = (Node) _delayNodeList.get(j);
                double value = 0;
                double[] distances = ((SingleSourceLongestPathAnalysis) (D
                        .get(column))).distance();
                Node predecessor = (Node) (predecessorMap.get(row));


                if ((i != j) || _delayNodeList.contains(predecessor)) {
                    value = distances[graph.nodeLabel(row)];
                } else {
                    value = distances[graph.nodeLabel(predecessor)];

View Full Code Here

    protected Object _compute() {
        ArrayList sourceNodes = new ArrayList();
        Iterator nodes = graph().nodes().iterator();


        while (nodes.hasNext()) {
            Node node = (Node) nodes.next();


            if (((DirectedGraph) graph()).inputEdgeCount(node) == 0) {
                sourceNodes.add(node);
            }
        }

View Full Code Here

                .reachableNodes(_dependencyGraph.node(inputPort));
        Set dependentOutputPorts = new HashSet();
        Iterator outputs = reachableOutputs.iterator();


        while (outputs.hasNext()) {
            Node node = (Node) outputs.next();
            dependentOutputPorts.add(node.getWeight());
        }


        return dependentOutputPorts;
    }

View Full Code Here

                .backwardReachableNodes(_dependencyGraph.node(outputPort));
        LinkedList dependentInputPorts = new LinkedList();
        Iterator inputs = backwardReachableInputs.iterator();


        while (inputs.hasNext()) {
            Node node = (Node) inputs.next();
            dependentInputPorts.add(node.getWeight());
        }


        return dependentInputPorts;
    }

View Full Code Here

0 1

TOP

Related Classes of ptolemy.graph.Node

ptolemy.actor.GraphReader

ptolemy.actor.util.ConstVariableModelAnalysis

ptolemy.actor.util.FunctionDependency

ptolemy.graph.analysis.strategy.AllEdgeSingleSourceLongestPathStrategy

ptolemy.graph.analysis.strategy.FloydWarshallAllPairShortestPathStrategy

ptolemy.graph.analysis.strategy.FloydWarshallTransitiveClosureStrategy

ptolemy.graph.analysis.strategy.KarpCycleMeanStrategy

ptolemy.graph.analysis.strategy.MirrorTransformerStrategy

ptolemy.graph.analysis.strategy.ParhiMaximumProfitToCostRatioStrategy

ptolemy.graph.analysis.strategy.SinkNodeStrategy

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.