private List<Vertex> getAdjacentes(Vertex vert) {
   List<Vertex> adj = new ArrayList<Vertex>();
   for (Edge arco : arcos) {
     if (arco.getSource().equals(vert) && !isVisited(arco.getDestination())) {
       adj.add(arco.getDestination());
     }
   }
   return adj;
 }
 private List<Vertex> getNeighbors(Vertex node) {
   List<Vertex> neighbors = new ArrayList<Vertex>();
   for (Edge edge : edges) {
     if (edge.getSource().equals(node) && !isSettled(edge.getDestination())) {
       neighbors.add(edge.getDestination());
     }
   }
   return neighbors;
 }
Exemple #3
0
  public boolean removeEdgeTo(Vertex destination) {
    for (Edge edge : getOutgoingEdges()) {
      if (edge.getDestination() == destination) {
        getOutgoingEdges().remove(edge);
        edge.getDestination().getIncomingEdges().remove(edge);
        graph.edges().remove(edge);
        return true;
      }
    }

    return false;
  }
 private static <T> void getPathFind(Graph<T> graph, HashMap<T, nodeBody<T>> path, T n1, T n2) {
   if (!(n1.equals(n2))) {
     for (Edge<T> e : graph.getEdgesFrom(n1)) {
       T neighbor = e.getDestination();
       if (!(path.containsKey(neighbor))) {
         path.put(neighbor, new nodeBody<T>());
       }
       int newCost = path.get(n1).getCost() + e.getWeight();
       nodeBody<T> nBody = path.get(neighbor);
       if (newCost < nBody.getCost()) {
         nBody.setCost(newCost);
         nBody.setFrom(n1);
       }
     }
     T next = null;
     int lowestCost = Integer.MAX_VALUE;
     for (T n : path.keySet()) {
       nodeBody<T> c = path.get(n);
       if (!c.isDone()) {
         if (c.getCost() < lowestCost) {
           next = n;
           lowestCost = c.getCost();
         }
       }
     }
     path.get(next).setDone(true);
     getPathFind(graph, path, next, n2);
   } else return;
 }
Exemple #5
0
 public void compAdjEdges(Vertex s, int w) {
   Vertex source = s;
   int vertWeight = w;
   int tempWeight;
   int origWeight;
   /* Each adjacent edge to the source Vertex,
    * (if it has not yet been handled)
    * has a weight which is added to the current pathWeight.
    * If this pathWeight is smaller than the one associated with
    * the given edge's vertex (destination.getWeight())
    * then the vertex's weight is updated and this path is
    * added to the priority queue
    */
   for (Edge e : source.adjacentD) {
     Edge curEdge = e;
     Vertex curVer = e.getDestination();
     origWeight = curVer.getWeight();
     if (curVer.known == false) {
       tempWeight = curEdge.getWeight();
       tempWeight = tempWeight + vertWeight;
       if (tempWeight < origWeight) {
         curVer.setWeight(tempWeight);
         curVer.previous = source;
         pq.add(curVer);
       }
     }
   }
 }
 private int getDistance(Vertex node, Vertex target) {
   for (Edge edge : edges) {
     if (edge.getSource().equals(node) && edge.getDestination().equals(target)) {
       return edge.getWeight();
     }
   }
   throw new RuntimeException("Should not happen");
 }
 private int getDistance(Vertex node, Vertex target) {
   for (Edge edge : arcos) {
     if (edge.getSource().equals(node) && edge.getDestination().equals(target)) {
       return edge.getWeight();
     }
   }
   throw new RuntimeException("Inalcancavel");
 }
Exemple #8
0
  @Override
  public T next() {
    if (hasNext()) {
      Edge<T> tmp = nextEdge;
      nextEdge = null;
      return source ? tmp.getSource().getData() : tmp.getDestination().getData();
    }

    throw new NoSuchElementException();
  }
Exemple #9
0
  public void removeAllEdges() {
    for (Edge edge : getIncomingEdges()) {
      edge.getSource().getOutgoingEdges().remove(edge);
    }
    incoming = null;

    for (Edge edge : getOutgoingEdges()) {
      edge.getDestination().getIncomingEdges().remove(edge);
    }
    outgoing = null;
  }
Exemple #10
0
  private void start(Graph<E> graph) {
    E min;

    while ((min = getMin()) != null) {
      // label min as visited
      unvisited.remove(min);

      // for each min neighbor...
      for (Edge<E> edge : graph.getOutboundEdges(min)) {
        int alt = dist.get(min) + edge.getWeight();

        if (alt < dist.get(edge.getDestination())) {
          // a shorter path was found!
          dist.put(edge.getDestination(), alt);
          prev.get(edge.getDestination()).clear();
          prev.get(edge.getDestination()).add(min);
        } else if (alt == dist.get(edge.getDestination())) {
          // another path was found!
          prev.get(edge.getDestination()).add(min);
        }
      }
    }
  }
  private static <T> List<Edge<T>> getPathReturn(
      Graph<T> graph, HashMap<T, nodeBody<T>> path, T n1, T n2) {

    if (!(n1.equals(n2))) {
      T next = path.get(n1).getFrom();
      Edge<T> RetE = null;
      int lowestCost = Integer.MAX_VALUE;
      for (Edge<T> e : graph.getEdgesBetween(n1, next)) {
        if ((e.getWeight() < lowestCost) && (e.getDestination().equals(n1))) {
          RetE = e;
          lowestCost = e.getWeight();
        }
      }
      for (Edge<T> e : graph.getEdgesBetween(next, n1)) {
        if ((e.getWeight() < lowestCost) && (e.getDestination().equals(n1))) {
          RetE = e;
          lowestCost = e.getWeight();
        }
      }
      List<Edge<T>> l = getPathReturn(graph, path, next, n2);
      l.add(RetE);
      return l;
    } else return new ArrayList<Edge<T>>();
  }
  @Override
  /** Computes the shortest path from the startId given to all other vertices */
  public void computeShortestPath() throws IllegalStateException {
    vertices = new ArrayList<Vertex>();
    isComputed = true;
    Vertex currentVertex = startGraph.getData(startId);
    PriorityQueue<Vertex> vertexList = new PriorityQueue<Vertex>();
    vertexList.add(currentVertex);
    currentVertex.setDistance(0);

    // Here we reset the vertex colors after every calculation
    for (Vertex vertex : (ArrayList<Vertex>) ((CoffeeGraph) startGraph).getVertexList()) {
      vertex.setColor(0);
    }

    // Basic implementation of Dijkstras algorithm.
    while (!vertexList.isEmpty()) {
      currentVertex = vertexList.poll();
      if (currentVertex.getColor() == 0) {
        currentVertex.setColor(1);
        for (Edge edge : currentVertex.getEdgeSet()) {

          Vertex tempVertex = edge.getDestination();
          double tempDistance = weighing.weight(edge);
          double totalDistance = currentVertex.getDistance() + tempDistance;
          if (totalDistance < tempVertex.getDistance()) {
            vertexList.remove(tempVertex);
            tempVertex.setDistance(totalDistance);
            tempVertex.setPrevious(currentVertex);
            vertexList.add(tempVertex);
            if (!vertices.contains(tempVertex)) {
              vertices.add(tempVertex);
            }
          }
        }
      }
    }
  }
  /** Construct the parallel composition of two PTAs. */
  public PTA compose(PTA pta1, PTA pta2) {
    Set<String> alpha1, alpha2, alpha1only, alpha2only, sync;
    Transition transition;
    Edge edge;
    double prob;
    IndexPair state;
    int src, dest;

    // Store PTAs locally and create new one to store parallel composition
    this.pta1 = pta1;
    this.pta2 = pta2;
    par = new PTA();

    // New set of clocks is union of sets for two PTAs
    for (String s : pta1.clockNames) {
      par.getOrAddClock(s);
    }
    for (String s : pta2.clockNames) {
      par.getOrAddClock(s);
    }

    // Get alphabets, compute intersection etc.
    alpha1 = pta1.getAlphabet();
    alpha2 = pta2.getAlphabet();
    // System.out.println("alpha1: " + alpha1);
    // System.out.println("alpha2: " + alpha2);
    sync = new LinkedHashSet<String>();
    alpha1only = new LinkedHashSet<String>();
    alpha2only = new LinkedHashSet<String>();
    for (String a : alpha1) {
      if (!("".equals(a)) && alpha2.contains(a)) {
        sync.add(a);
      } else {
        alpha1only.add(a);
      }
    }
    for (String a : alpha2) {
      if (!alpha1.contains(a)) {
        alpha2only.add(a);
      }
    }
    // Explicitly add tau to action lists
    alpha1only.add("");
    alpha2only.add("");
    // System.out.println("alpha1only: " + alpha1only);
    // System.out.println("alpha2only: " + alpha2only);
    // System.out.println("sync: " + sync);

    // Initialise states storage
    states = new IndexedSet<IndexPair>();
    explore = new LinkedList<IndexPair>();
    // Add initial location
    addState(0, 0);
    src = -1;
    while (!explore.isEmpty()) {
      // Pick next state to explore
      // (they are stored in order found so know index is src+1)
      state = explore.removeFirst();
      src++;
      // Go through asynchronous transitions of PTA 1
      for (String a : alpha1only) {
        for (Transition transition1 : pta1.getTransitionsByAction(state.i1, a)) {
          // Create new transition
          transition = par.addTransition(src, a);
          // Copy guard
          for (Constraint c : transition1.getGuardConstraints())
            transition.addGuardConstraint(c.deepCopy().renameClocks(pta1, par));
          // Combine edges
          for (Edge edge1 : transition1.getEdges()) {
            prob = edge1.getProbability();
            dest = addState(edge1.getDestination(), state.i2);
            edge = transition.addEdge(prob, dest);
            // Copy resets
            for (Map.Entry<Integer, Integer> e : edge1.getResets()) {
              edge.addReset(PTA.renameClock(pta1, par, e.getKey()), e.getValue());
            }
          }
        }
      }
      // Go through asynchronous transitions of PTA 2
      for (String a : alpha2only) {
        for (Transition transition2 : pta2.getTransitionsByAction(state.i2, a)) {
          // Create new transition
          transition = par.addTransition(src, a);
          // Copy guard
          for (Constraint c : transition2.getGuardConstraints())
            transition.addGuardConstraint(c.deepCopy().renameClocks(pta2, par));
          // Combine edges
          for (Edge edge2 : transition2.getEdges()) {
            prob = edge2.getProbability();
            dest = addState(state.i1, edge2.getDestination());
            edge = transition.addEdge(prob, dest);
            // Copy resets
            for (Map.Entry<Integer, Integer> e : edge2.getResets()) {
              edge.addReset(PTA.renameClock(pta2, par, e.getKey()), e.getValue());
            }
          }
        }
      }
      // Go through synchronous transitions
      for (String a : sync) {
        for (Transition transition1 : pta1.getTransitionsByAction(state.i1, a)) {
          for (Transition transition2 : pta2.getTransitionsByAction(state.i2, a)) {
            // Create new transition
            transition = par.addTransition(src, a);
            // Guard is conjunction of guards
            for (Constraint c : transition1.getGuardConstraints())
              transition.addGuardConstraint(c.deepCopy().renameClocks(pta1, par));
            for (Constraint c : transition2.getGuardConstraints())
              transition.addGuardConstraint(c.deepCopy().renameClocks(pta2, par));
            // Combine edges
            for (Edge edge1 : transition1.getEdges()) {
              for (Edge edge2 : transition2.getEdges()) {
                prob = edge1.getProbability() * edge2.getProbability();
                dest = addState(edge1.getDestination(), edge2.getDestination());
                edge = transition.addEdge(prob, dest);
                // Reset set is union of reset sets
                for (Map.Entry<Integer, Integer> e : edge1.getResets()) {
                  edge.addReset(PTA.renameClock(pta1, par, e.getKey()), e.getValue());
                }
                for (Map.Entry<Integer, Integer> e : edge2.getResets()) {
                  edge.addReset(PTA.renameClock(pta2, par, e.getKey()), e.getValue());
                }
              }
            }
          }
        }
      }
    }

    return par;
  }
  /** Build a time bounded reachability query into a PTA; return the new target location set. */
  private BitSet buildTimeBoundIntoPta(
      PTA pta, BitSet targetLocs, int timeBound, boolean timeBoundStrict) {
    String timerClock = null;
    int timerClockIndex, numLocs, newTargetLoc;
    String newTargetLocString;
    List<Transition> trNewList;
    Transition trNew;
    BitSet targetLocsNew;
    boolean toTarget;
    int i;

    // Add a timer clock
    timerClock = "time";
    while (pta.getClockIndex(timerClock) != -1) timerClock += "_";
    timerClockIndex = pta.addClock(timerClock);
    // Add a new target location
    numLocs = pta.getNumLocations();
    newTargetLocString = "target";
    while (pta.getLocationIndex(newTargetLocString) != -1) newTargetLocString += "_";
    newTargetLoc = pta.addLocation(newTargetLocString);
    // Go through old (on-target) locations
    for (i = 0; i < numLocs; i++) {
      trNewList = new ArrayList<Transition>();
      for (Transition tr : pta.getTransitions(i)) {
        // See if the transition can go to a target location
        toTarget = false;
        for (Edge e : tr.getEdges()) {
          if (targetLocs.get(e.getDestination())) {
            toTarget = true;
            break;
          }
        }
        // Copy transition, modify edges going to target and add guard
        if (toTarget) {
          trNew = new Transition(tr);
          for (Edge e : trNew.getEdges()) {
            if (targetLocs.get(e.getDestination())) {
              e.setDestination(newTargetLoc);
            }
          }
          if (timeBoundStrict)
            trNew.addGuardConstraint(Constraint.buildLt(timerClockIndex, timeBound));
          else trNew.addGuardConstraint(Constraint.buildLeq(timerClockIndex, timeBound));
          trNewList.add(trNew);
          // Modify guard of copied transition
          if (timeBoundStrict)
            tr.addGuardConstraint(Constraint.buildGeq(timerClockIndex, timeBound));
          else tr.addGuardConstraint(Constraint.buildGt(timerClockIndex, timeBound));
        }
      }
      // Add new transitions to PTA
      for (Transition tr : trNewList) {
        pta.addTransition(tr);
      }
    }
    // Re-generate set of target locations
    targetLocsNew = new BitSet(pta.getNumLocations());
    targetLocsNew.set(newTargetLoc);

    return targetLocsNew;
  }
 private static <T> void depthFirstSearch(Graph<T> graph, T n, Set<T> v) {
   v.add(n);
   for (Edge<T> e : graph.getEdgesFrom(n))
     if (!v.contains(e.getDestination())) depthFirstSearch(graph, e.getDestination(), v);
 }