/**
   * Like {@link #edgeLength(Graph,String)} but use an existing edge as argument.
   *
   * @param edge
   * @return The edge length or -1 if the nodes of the edge have no positions.
   */
  public static double edgeLength(Edge edge) {
    double xyz0[] = nodePosition(edge.getNode0());
    double xyz1[] = nodePosition(edge.getNode1());

    if (xyz0 == null || xyz1 == null) return -1;

    xyz0[0] = xyz1[0] - xyz0[0];
    xyz0[1] = xyz1[1] - xyz0[1];
    xyz0[2] = xyz1[2] - xyz0[2];

    return Math.sqrt(xyz0[0] * xyz0[0] + xyz0[1] * xyz0[1] + xyz0[2] * xyz0[2]);
  }
Example #2
0
  /*
   * (non-Javadoc)
   *
   * @see org.graphstream.algorithm.Algorithm#compute()
   */
  @SuppressWarnings("unchecked")
  public void compute() {
    Node source = graph.getNode(this.source_id);

    // Step 1: Initialize graph

    for (Node n : graph) {
      if (n == source) n.addAttribute(identifier + ".distance", 0.0);
      else n.addAttribute(identifier + ".distance", Double.POSITIVE_INFINITY);

      // n.addAttribute(identifier+".predecessors",(Object)null);
    }

    // Step 2: relax edges repeatedly

    for (int i = 0; i < graph.getNodeCount(); i++) {
      for (Edge e : graph.getEachEdge()) {
        Node n0 = e.getNode0();
        Node n1 = e.getNode1();
        Double d0 = (Double) n0.getAttribute(identifier + ".distance");
        Double d1 = (Double) n1.getAttribute(identifier + ".distance");

        Double we = (Double) e.getAttribute(weightAttribute);
        if (we == null)
          throw new NumberFormatException(
              "org.graphstream.algorithm.BellmanFord: Problem with attribute \""
                  + weightAttribute
                  + "\" on edge "
                  + e);

        if (d0 != null) {
          if (d1 == null || d1 >= d0 + we) {
            n1.addAttribute(identifier + ".distance", d0 + we);
            ArrayList<Edge> predecessors =
                (ArrayList<Edge>) n1.getAttribute(identifier + ".predecessors");

            if (d1 != null && d1 == d0 + we) {
              if (predecessors == null) {
                predecessors = new ArrayList<Edge>();
              }
            } else {
              predecessors = new ArrayList<Edge>();
            }
            if (!predecessors.contains(e)) {
              predecessors.add(e);
            }

            n1.addAttribute(identifier + ".predecessors", predecessors);
          }
        }
      }
    }

    // Step 3: check for negative-weight cycles

    for (Edge e : graph.getEachEdge()) {
      Node n0 = e.getNode0();
      Node n1 = e.getNode1();
      Double d0 = (Double) n0.getAttribute(identifier + ".distance");
      Double d1 = (Double) n1.getAttribute(identifier + ".distance");

      Double we = (Double) e.getAttribute(weightAttribute);

      if (we == null) {
        throw new NumberFormatException(
            String.format(
                "%s: Problem with attribute \"%s\" on edge \"%s\"",
                BellmanFord.class.getName(), weightAttribute, e.getId()));
      }

      if (d1 > d0 + we) {
        throw new NumberFormatException(
            String.format(
                "%s: Problem: negative weight, cycle detected on edge \"%s\"",
                BellmanFord.class.getName(), e.getId()));
      }
    }
  }