コード例 #1
0
ファイル: PcMax.java プロジェクト: renjiey/tetrad
 public Set<Edge> getNonadjacencies() {
   Graph complete = GraphUtils.completeGraph(graph);
   Set<Edge> nonAdjacencies = complete.getEdges();
   Graph undirected = GraphUtils.undirectedGraph(graph);
   nonAdjacencies.removeAll(undirected.getEdges());
   return new HashSet<Edge>(nonAdjacencies);
 }
コード例 #2
0
  /**
   * Transforms a maximally directed pattern (PDAG) represented in graph <code>g</code> into an
   * arbitrary DAG by modifying <code>g</code> itself. Based on the algorithm described in
   * Chickering (2002) "Optimal structure identification with greedy search" Journal of Machine
   * Learning Research. R. Silva, June 2004
   */
  public static void pdagToDag(Graph g) {
    Graph p = new EdgeListGraph(g);
    List<Edge> undirectedEdges = new ArrayList<Edge>();

    for (Edge edge : g.getEdges()) {
      if (edge.getEndpoint1() == Endpoint.TAIL
          && edge.getEndpoint2() == Endpoint.TAIL
          && !undirectedEdges.contains(edge)) {
        undirectedEdges.add(edge);
      }
    }
    g.removeEdges(undirectedEdges);
    List<Node> pNodes = p.getNodes();

    do {
      Node x = null;

      for (Node pNode : pNodes) {
        x = pNode;

        if (p.getChildren(x).size() > 0) {
          continue;
        }

        Set<Node> neighbors = new HashSet<Node>();

        for (Edge edge : p.getEdges()) {
          if (edge.getNode1() == x || edge.getNode2() == x) {
            if (edge.getEndpoint1() == Endpoint.TAIL && edge.getEndpoint2() == Endpoint.TAIL) {
              if (edge.getNode1() == x) {
                neighbors.add(edge.getNode2());
              } else {
                neighbors.add(edge.getNode1());
              }
            }
          }
        }
        if (neighbors.size() > 0) {
          Collection<Node> parents = p.getParents(x);
          Set<Node> all = new HashSet<Node>(neighbors);
          all.addAll(parents);
          if (!GraphUtils.isClique(all, p)) {
            continue;
          }
        }

        for (Node neighbor : neighbors) {
          Node node1 = g.getNode(neighbor.getName());
          Node node2 = g.getNode(x.getName());

          g.addDirectedEdge(node1, node2);
        }
        p.removeNode(x);
        break;
      }
      pNodes.remove(x);
    } while (pNodes.size() > 0);
  }
コード例 #3
0
ファイル: PcMax.java プロジェクト: renjiey/tetrad
 public Set<Edge> getAdjacencies() {
   Set<Edge> adjacencies = new HashSet<Edge>();
   for (Edge edge : graph.getEdges()) {
     adjacencies.add(edge);
   }
   return adjacencies;
 }
コード例 #4
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
  public Graph orient() {
    Graph skeleton = GraphUtils.undirectedGraph(getPattern());
    Graph graph = new EdgeListGraph(skeleton.getNodes());

    List<Node> nodes = skeleton.getNodes();
    //        Collections.shuffle(nodes);

    if (isR1Done()) {
      ruleR1(skeleton, graph, nodes);
    }

    for (Edge edge : skeleton.getEdges()) {
      if (!graph.isAdjacentTo(edge.getNode1(), edge.getNode2())) {
        graph.addUndirectedEdge(edge.getNode1(), edge.getNode2());
      }
    }

    if (isR2Done()) {
      ruleR2(skeleton, graph);
    }

    if (isMeekDone()) {
      new MeekRules().orientImplied(graph);
    }

    return graph;
  }
コード例 #5
0
  /** Get a graph and direct only the unshielded colliders. */
  public static void basicPattern(Graph graph) {
    Set<Edge> undirectedEdges = new HashSet<Edge>();

    NEXT_EDGE:
    for (Edge edge : graph.getEdges()) {
      Node head = null, tail = null;

      if (edge.getEndpoint1() == Endpoint.ARROW && edge.getEndpoint2() == Endpoint.TAIL) {
        head = edge.getNode1();
        tail = edge.getNode2();
      } else if (edge.getEndpoint2() == Endpoint.ARROW && edge.getEndpoint1() == Endpoint.TAIL) {
        head = edge.getNode2();
        tail = edge.getNode1();
      }

      if (head != null) {
        for (Node node : graph.getParents(head)) {
          if (node != tail && !graph.isAdjacentTo(tail, node)) {
            continue NEXT_EDGE;
          }
        }

        undirectedEdges.add(edge);
      }
    }

    for (Edge nextUndirected : undirectedEdges) {
      Node node1 = nextUndirected.getNode1(), node2 = nextUndirected.getNode2();

      graph.removeEdge(nextUndirected);
      graph.addUndirectedEdge(node1, node2);
    }
  }
コード例 #6
0
ファイル: TestMimbuild3.java プロジェクト: jdramsey/tetrad
  private Graph condense(Graph mimStructure, Graph mimbuildStructure) {
    //        System.out.println("Uncondensed: " + mimbuildStructure);

    Map<Node, Node> substitutions = new HashMap<Node, Node>();

    for (Node node : mimbuildStructure.getNodes()) {
      for (Node _node : mimStructure.getNodes()) {
        if (node.getName().startsWith(_node.getName())) {
          substitutions.put(node, _node);
          break;
        }

        substitutions.put(node, node);
      }
    }

    HashSet<Node> nodes = new HashSet<Node>(substitutions.values());
    Graph graph = new EdgeListGraph(new ArrayList<Node>(nodes));

    for (Edge edge : mimbuildStructure.getEdges()) {
      Node node1 = substitutions.get(edge.getNode1());
      Node node2 = substitutions.get(edge.getNode2());

      if (node1 == node2) continue;

      if (graph.isAdjacentTo(node1, node2)) continue;

      graph.addEdge(new Edge(node1, node2, edge.getEndpoint1(), edge.getEndpoint2()));
    }

    //        System.out.println("Condensed: " + graph);

    return graph;
  }
コード例 #7
0
  public GraphIndex(Graph graph) {
    LOG.info("Indexing graph...");

    for (String feedId : graph.getFeedIds()) {
      for (Agency agency : graph.getAgencies(feedId)) {
        Map<String, Agency> agencyForId = agenciesForFeedId.getOrDefault(feedId, new HashMap<>());
        agencyForId.put(agency.getId(), agency);
        this.agenciesForFeedId.put(feedId, agencyForId);
      }
    }

    Collection<Edge> edges = graph.getEdges();
    /* We will keep a separate set of all vertices in case some have the same label.
     * Maybe we should just guarantee unique labels. */
    Set<Vertex> vertices = Sets.newHashSet();
    for (Edge edge : edges) {
      vertices.add(edge.getFromVertex());
      vertices.add(edge.getToVertex());
      if (edge instanceof TablePatternEdge) {
        TablePatternEdge patternEdge = (TablePatternEdge) edge;
        TripPattern pattern = patternEdge.getPattern();
        patternForId.put(pattern.code, pattern);
      }
    }
    for (Vertex vertex : vertices) {
      vertexForId.put(vertex.getLabel(), vertex);
      if (vertex instanceof TransitStop) {
        TransitStop transitStop = (TransitStop) vertex;
        Stop stop = transitStop.getStop();
        stopForId.put(stop.getId(), stop);
        stopVertexForStop.put(stop, transitStop);
        stopsForParentStation.put(stop.getParentStation(), stop);
      }
    }
    for (TransitStop stopVertex : stopVertexForStop.values()) {
      Envelope envelope = new Envelope(stopVertex.getCoordinate());
      stopSpatialIndex.insert(envelope, stopVertex);
    }
    for (TripPattern pattern : patternForId.values()) {
      patternsForFeedId.put(pattern.getFeedId(), pattern);
      patternsForRoute.put(pattern.route, pattern);

      for (Trip trip : pattern.getTrips()) {
        patternForTrip.put(trip, pattern);
        tripForId.put(trip.getId(), trip);
      }
      for (Stop stop : pattern.getStops()) {
        patternsForStop.put(stop, pattern);
      }
    }
    for (Route route : patternsForRoute.asMap().keySet()) {
      routeForId.put(route.getId(), route);
    }

    // Copy these two service indexes from the graph until we have better ones.
    calendarService = graph.getCalendarService();
    serviceCodes = graph.serviceCodes;
    this.graph = graph;
    LOG.info("Done indexing graph.");
  }
コード例 #8
0
ファイル: GesConcurrent.java プロジェクト: renjiey/tetrad
  /**
   * Forward equivalence search.
   *
   * @param graph The graph in the state prior to the forward equivalence search.
   */
  private void fes(Graph graph, List<Node> nodes) {
    TetradLogger.getInstance().log("info", "** FORWARD EQUIVALENCE SEARCH");

    lookupArrows = new HashMap<OrderedPair, Set<Arrow>>();

    initializeArrowsForward(nodes);

    while (!sortedArrows.isEmpty()) {
      Arrow arrow = sortedArrows.first();
      sortedArrows.remove(arrow);

      Node x = arrow.getX();
      Node y = arrow.getY();

      clearArrow(x, y);

      if (graph.isAdjacentTo(x, y)) {
        continue;
      }

      if (!validInsert(x, y, arrow.getHOrT(), arrow.getNaYX(), graph)) {
        continue;
      }

      List<Node> t = arrow.getHOrT();
      double bump = arrow.getBump();

      Set<Edge> edges = graph.getEdges();

      insert(x, y, t, graph, bump);
      score += bump;
      rebuildPattern(graph);

      // Try to avoid duplicating scoring calls. First clear out all of the edges that need to be
      // changed,
      // then change them, checking to see if they're already been changed. I know, roundabout, but
      // there's
      // a performance boost.
      for (Edge edge : graph.getEdges()) {
        if (!edges.contains(edge)) {
          reevaluateForward(graph, nodes, edge.getNode1(), edge.getNode2());
        }
      }

      storeGraph(graph);
    }
  }
コード例 #9
0
ファイル: NETWriter.java プロジェクト: jeffg2k/blueprints
 private void populateLists(List<Vertex> verticies, List<Edge> edges) {
   for (Vertex v : graph.getVertices()) {
     verticies.add(v);
   }
   for (Edge e : graph.getEdges()) {
     edges.add(e);
   }
 }
コード例 #10
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
  private boolean isUndirected(Graph graph, Node x, Node y) {
    List<Edge> edges = graph.getEdges(x, y);
    if (edges.size() == 1) {
      Edge edge = graph.getEdge(x, y);
      return Edges.isUndirectedEdge(edge);
    }

    return false;
  }
コード例 #11
0
ファイル: GesSearchEditor.java プロジェクト: jdramsey/tetrad
  private void calcStats() {
    //        Graph resultGraph = getAlgorithmRunner().getResultGraph();
    IGesRunner runner = (IGesRunner) getAlgorithmRunner();

    if (runner.getTopGraphs().isEmpty()) {
      throw new IllegalArgumentException(
          "No patterns were recorded. Please adjust the number of " + "patterns to store.");
    }

    Graph resultGraph = runner.getTopGraphs().get(runner.getIndex()).getGraph();

    if (getAlgorithmRunner().getDataModel() instanceof DataSet) {

      // resultGraph may be the output of a PC search.
      // Such graphs sometimes contain doubly directed edges.

      // /We converte such edges to directed edges here.
      // For the time being an orientation is arbitrarily selected.
      Set<Edge> allEdges = resultGraph.getEdges();

      for (Edge edge : allEdges) {
        if (edge.getEndpoint1() == Endpoint.ARROW && edge.getEndpoint2() == Endpoint.ARROW) {
          // Option 1 orient it from node1 to node2
          resultGraph.setEndpoint(edge.getNode1(), edge.getNode2(), Endpoint.ARROW);

          // Option 2 remove such edges:
          resultGraph.removeEdge(edge);
        }
      }

      Pattern pattern = new Pattern(resultGraph);
      PatternToDag ptd = new PatternToDag(pattern);
      Graph dag = ptd.patternToDagMeekRules();

      DataSet dataSet = (DataSet) getAlgorithmRunner().getDataModel();
      String report;

      if (dataSet.isContinuous()) {
        report = reportIfContinuous(dag, dataSet);
      } else if (dataSet.isDiscrete()) {
        report = reportIfDiscrete(dag, dataSet);
      } else {
        throw new IllegalArgumentException("");
      }

      JScrollPane dagWorkbenchScroll = dagWorkbenchScroll(dag);
      modelStatsText.setLineWrap(true);
      modelStatsText.setWrapStyleWord(true);
      modelStatsText.setText(report);

      removeStatsTabs();
      tabbedPane.addTab("DAG in pattern", dagWorkbenchScroll);
      tabbedPane.addTab("DAG Model Statistics", modelStatsText);
    }
  }
コード例 #12
0
  private void uncorrelationExogenousVariables() {
    Graph graph = getWorkbench().getGraph();

    Set<Edge> edges = graph.getEdges();

    for (Edge edge : edges) {
      if (Edges.isBidirectedEdge(edge)) {
        try {
          graph.removeEdge(edge);
        } catch (Exception e) {
          // Ignore.
        }
      }
    }
  }
コード例 #13
0
ファイル: Knowledge2.java プロジェクト: ps7z/tetrad
  public boolean isViolatedBy(Graph graph) {
    for (Edge edge : graph.getEdges()) {
      if (!edge.isDirected()) {
        continue;
      }

      Node from = Edges.getDirectedEdgeTail(edge);
      Node to = Edges.getDirectedEdgeHead(edge);

      if (isForbidden(from.getName(), to.getName())) {
        return true;
      }
    }

    return false;
  }
コード例 #14
0
ファイル: TestSearchGraph.java プロジェクト: jdramsey/tetrad
  public static Graph weightedRandomGraph(int n, int e) {
    List<Node> nodes = new ArrayList<Node>();
    for (int i = 0; i < n; i++) nodes.add(new GraphNode("X" + i));

    Graph graph = new EdgeListGraph(nodes);

    for (int e0 = 0; e0 < e; e0++) {
      int i1 = weightedRandom(nodes, graph);
      //            int i2 = RandomUtil.getInstance().nextInt(n);
      int i2 = weightedRandom(nodes, graph);

      if (!(shortestPath(nodes.get(i1), nodes.get(i2), graph) < 9)) {
        e0--;
        continue;
      }

      if (i1 == i2) {
        e0--;
        continue;
      }

      Edge edge = Edges.undirectedEdge(nodes.get(i1), nodes.get(i2));

      if (graph.containsEdge(edge)) {
        e0--;
        continue;
      }

      graph.addEdge(edge);
    }

    for (Edge edge : graph.getEdges()) {
      Node n1 = edge.getNode1();
      Node n2 = edge.getNode2();

      if (!graph.isAncestorOf(n2, n1)) {
        graph.removeEdge(edge);
        graph.addDirectedEdge(n1, n2);
      } else {
        graph.removeEdge(edge);
        graph.addDirectedEdge(n2, n1);
      }
    }

    return graph;
  }
コード例 #15
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
  private void ruleR2(Graph skeleton, Graph graph) {
    Set<Edge> edgeList1 = skeleton.getEdges();
    //        Collections.shuffle(edgeList1);

    for (Edge adj : edgeList1) {
      Node x = adj.getNode1();
      Node y = adj.getNode2();

      if (!isR2Orient2Cycles() && isTwoCycle(graph, x, y)) {
        continue;
      }

      if (!isTwoCycle(graph, x, y) && !isUndirected(graph, x, y)) {
        continue;
      }

      resolveOneEdgeMax(graph, x, y, isStrongR2(), new EdgeListGraph(graph));
    }
  }
コード例 #16
0
ファイル: GesConcurrent.java プロジェクト: renjiey/tetrad
  /** Get all nodes that are connected to Y by an undirected edge and not adjacent to X. */
  private static List<Node> getTNeighbors(Node x, Node y, Graph graph) {
    List<Edge> yEdges = graph.getEdges(y);
    List<Node> tNeighbors = new ArrayList<Node>();

    for (Edge edge : yEdges) {
      if (!Edges.isUndirectedEdge(edge)) {
        continue;
      }

      Node z = edge.getDistalNode(y);

      if (graph.isAdjacentTo(z, x)) {
        continue;
      }

      tNeighbors.add(z);
    }

    return tNeighbors;
  }
コード例 #17
0
ファイル: GesConcurrent.java プロジェクト: renjiey/tetrad
  /**
   * Find all nodes that are connected to Y by an undirected edge that are adjacent to X (that is,
   * by undirected or directed edge).
   */
  private static List<Node> getNaYX(Node x, Node y, Graph graph) {
    List<Edge> yEdges = graph.getEdges(y);
    List<Node> nayx = new ArrayList<Node>();

    for (Edge edge : yEdges) {
      if (!Edges.isUndirectedEdge(edge)) {
        continue;
      }

      Node z = edge.getDistalNode(y);

      if (!graph.isAdjacentTo(z, x)) {
        continue;
      }

      nayx.add(z);
    }

    return nayx;
  }
コード例 #18
0
  private void correlateExogenousVariables() {
    Graph graph = getWorkbench().getGraph();

    if (graph instanceof Dag) {
      JOptionPane.showMessageDialog(
          JOptionUtils.centeringComp(), "Cannot add bidirected edges to DAG's.");
      return;
    }

    List<Node> nodes = graph.getNodes();

    List<Node> exoNodes = new LinkedList<Node>();

    for (int i = 0; i < nodes.size(); i++) {
      Node node = nodes.get(i);
      if (graph.isExogenous(node)) {
        exoNodes.add(node);
      }
    }

    for (int i = 0; i < exoNodes.size(); i++) {

      loop:
      for (int j = i + 1; j < exoNodes.size(); j++) {
        Node node1 = exoNodes.get(i);
        Node node2 = exoNodes.get(j);
        List<Edge> edges = graph.getEdges(node1, node2);

        for (int k = 0; k < edges.size(); k++) {
          Edge edge = edges.get(k);
          if (Edges.isBidirectedEdge(edge)) {
            continue loop;
          }
        }

        graph.addBidirectedEdge(node1, node2);
      }
    }
  }
コード例 #19
0
ファイル: GesConcurrent.java プロジェクト: renjiey/tetrad
  private void initializeArrowsBackward(Graph graph) {
    sortedArrows.clear();
    lookupArrows.clear();

    for (Edge edge : graph.getEdges()) {
      Node x = edge.getNode1();
      Node y = edge.getNode2();

      if (!knowledgeEmpty()) {
        if (!getKnowledge().noEdgeRequired(x.getName(), y.getName())) {
          continue;
        }
      }

      if (Edges.isDirectedEdge(edge)) {
        calculateArrowsBackward(x, y, graph);
      } else {
        calculateArrowsBackward(x, y, graph);
        calculateArrowsBackward(y, x, graph);
      }
    }
  }
コード例 #20
0
ファイル: GesConcurrent.java プロジェクト: renjiey/tetrad
  private Graph pickDag(Graph graph) {
    SearchGraphUtils.basicPattern(graph, false);
    addRequiredEdges(graph);
    boolean containsUndirected;

    do {
      containsUndirected = false;

      for (Edge edge : graph.getEdges()) {
        if (Edges.isUndirectedEdge(edge)) {
          containsUndirected = true;
          graph.removeEdge(edge);
          Edge _edge = Edges.directedEdge(edge.getNode1(), edge.getNode2());
          graph.addEdge(_edge);
        }
      }

      meekOrient(graph, getKnowledge());
    } while (containsUndirected);

    return graph;
  }
コード例 #21
0
ファイル: DijkstraAlgorithm.java プロジェクト: njiang/SRouter
 public DijkstraAlgorithm(Graph graph) {
   // create a copy of the array so that we can operate on this array
   this.nodes = new ArrayList<Vertex>(graph.getVertexes());
   this.edges = new ArrayList<Edge>(graph.getEdges());
 }
コード例 #22
0
 protected void editSelectAll() {
   gp.getSelection().addNodes(graph.getNodes());
   gp.getSelection().addEdges(graph.getEdges());
   gp.repaint();
 }
コード例 #23
0
ファイル: Test.java プロジェクト: peterrodgers/vennom
  public static void main(String[] args) {

    System.out.println("Start Graph Tests");

    System.out.println("Test 1 START: Basic Node and edge methods");

    // Graph creation and deletion
    Graph g1 = new Graph();
    Node nX = new Node("nY");
    Node nY = new Node("nX");
    if (!g1.addNode(nX)) {
      System.out.println("Test1.0.1 Fail");
    }
    if (!g1.addNode(nY)) {
      System.out.println("Test1.0.2 Fail");
    }
    if (g1.addNode(nY)) {
      System.out.println("Test1.0.3 Fail");
    }
    Edge eX = new Edge(nX, nY);
    if (!g1.addEdge(eX)) {
      System.out.println("Test1.0.4 Fail");
    }
    if (g1.addEdge(eX)) {
      System.out.println("Test1.0.5 Fail");
    }

    // test the consistency checker
    if (!g1.consistent()) {
      System.out.println("Test1.0.6 Fail");
    }

    ArrayList<Edge> nYTo = nY.getEdgesTo();
    nYTo.remove(eX);
    if (g1.consistent()) {
      System.out.println("Test1.0.7 Fail");
    }
    nYTo.add(eX);
    if (!g1.consistent()) {
      System.out.println("Test1.0.8 Fail");
    }
    ArrayList<Edge> g1Edges = g1.getEdges();
    g1Edges.remove(eX);
    if (g1.consistent()) {
      System.out.println("Test1.0.9 Fail");
    }
    g1Edges.add(eX);
    if (!g1.consistent()) {
      System.out.println("Test1.0.10 Fail");
    }

    Node nOutside = new Node();
    eX.setFrom(nOutside);
    if (g1.consistent()) {
      System.out.println("Test1.0.11 Fail");
    }
    eX.setFrom(nX);
    if (!g1.consistent()) {
      System.out.println("Test1.0.12 Fail");
    }

    g1 = new Graph("G");
    if (!g1.getLabel().equals("G")) {
      System.out.println("Test1.0.13 Fail");
    }
    g1.setLabel("H");
    if (!g1.getLabel().equals("H")) {
      System.out.println("Test1.0.14 Fail");
    }
    if (!g1.consistent()) {
      System.out.println("Test1.0.15 Fail");
    }

    /* first real test graph

                   ^e9v
     n1  e1> n2 e2> n3          n6
     e3v    e4^    e5ve6ve7^
      ---n4--- <e8 n5
    */

    // Graph Object creation

    g1.clear();
    Node n1 = new Node("n1");
    if (!g1.addNode(n1)) {
      System.out.println("Test1.1.1 Fail");
    }
    Node n2 = new Node("n2");
    if (!g1.addNode(n2)) {
      System.out.println("Test1.1.2 Fail");
    }
    Node n3 = new Node();
    if (!g1.addNode(n3)) {
      System.out.println("Test1.1.3 Fail");
    }
    Node n4 = new Node("n4");
    if (!g1.addNode(n4)) {
      System.out.println("Test1.1.4 Fail");
    }
    Node n5 = new Node("test");
    if (!g1.addNode(n5)) {
      System.out.println("Test1.1.5 Fail");
    }
    Node n6 = new Node("n6");
    if (!g1.addNode(n6)) {
      System.out.println("Test1.1.6 Fail");
    }

    Edge e1 = new Edge(n6, n6);
    if (!g1.addEdge(e1)) {
      System.out.println("Test1.1.7 Fail");
    }
    Edge e2 = new Edge(n2, n3);
    if (!g1.addEdge(e2)) {
      System.out.println("Test1.1.8 Fail");
    }
    Edge e3 = new Edge(n1, n4);
    if (!g1.addEdge(e3)) {
      System.out.println("Test1.1.9 Fail");
    }
    Edge e4 = new Edge(n4, n2);
    if (!g1.addEdge(e4)) {
      System.out.println("Test1.1.10 Fail");
    }
    Edge e5 = new Edge(n3, n5);
    if (!g1.addEdge(e5)) {
      System.out.println("Test1.1.11 Fail");
    }
    Edge e6 = new Edge(n3, n5);
    if (!g1.addEdge(e6)) {
      System.out.println("Test1.1.12 Fail");
    }
    Edge e7 = new Edge(n3, n5);
    if (!g1.addEdge(e7)) {
      System.out.println("Test1.1.13 Fail");
    }
    Edge e8 = new Edge(n1, n1);
    if (!g1.addEdge(e8)) {
      System.out.println("Test1.1.14 Fail");
    }
    Edge e9 = new Edge(n3, n3);
    if (!g1.addEdge(e9)) {
      System.out.println("Test1.1.15 Fail");
    }

    // oposite end test
    if (e1.getOppositeEnd(n6) != n6) {
      System.out.println("Test1.1.16 Fail");
    }
    if (e2.getOppositeEnd(n2) != n3) {
      System.out.println("Test1.1.17 Fail");
    }
    if (e2.getOppositeEnd(n3) != n2) {
      System.out.println("Test1.1.18 Fail");
    }
    if (e2.getOppositeEnd(n6) != null) {
      System.out.println("Test1.1.19 Fail");
    }

    // changing the connections of edges
    e1.setFromTo(n4, n4);
    e1.setFrom(n5);
    e1.setTo(n5);
    e1.setFromTo(n3, n6);
    e1.setFromTo(n1, n2);
    e8.setFrom(n5);
    e8.setTo(n4);
    e7.reverse();
    e9.reverse();
    // resetting labels
    n3.setLabel("n3");
    n5.setLabel("n5");

    Node tempTo = e1.getTo();
    Node tempFrom = e1.getFrom();

    e1.reverse();
    if (e1.getTo() != tempFrom) {
      System.out.println("Test1.1.20 Fail");
    }

    if (e1.getFrom() != tempTo) {
      System.out.println("Test1.1.21 Fail");
    }

    e1.reverse();

    if (e1.getTo() != tempTo) {
      System.out.println("Test1.1.22 Fail");
    }

    if (e1.getFrom() != tempFrom) {
      System.out.println("Test1.1.23 Fail");
    }

    if (!g1.consistent()) {
      System.out.println("Test1.1.24 Fail");
    }

    // Node connectivity testing
    HashSet<Node> testN = new HashSet<Node>();

    if (!n6.connectingNodes().equals(testN)) {
      System.out.println("Test1.2.1 Fail");
    }
    if (!n6.unvisitedConnectingNodes().equals(testN)) {
      System.out.println("Test1.2.2 Fail");
    }
    if (!n6.connectingEdges().equals(testN)) {
      System.out.println("Test1.2.4 Fail");
    }

    testN = new HashSet<Node>();
    testN.add(n5);
    testN.add(n3);
    testN.add(n2);

    if (!n3.connectingNodes().equals(testN)) {
      System.out.println("Test1.2.5 Fail");
    }

    if (!n3.unvisitedConnectingNodes().equals(testN)) {
      System.out.println("Test1.2.7 Fail");
    }

    // Node visited flag testing

    n2.setVisited(true);

    if (!n3.connectingNodes().equals(testN)) {
      System.out.println("Test1.3.1 Fail");
    }
    testN.remove(n2);
    if (!n3.unvisitedConnectingNodes().equals(testN)) {
      System.out.println("Test1.3.3 Fail");
    }

    g1.setNodesVisited(true);
    testN = new HashSet<Node>();

    if (!n3.unvisitedConnectingNodes().equals(testN)) {
      System.out.println("Test1.3.4 Fail");
    }

    n2.setVisited(false);
    testN.add(n2);

    if (!n3.unvisitedConnectingNodes().equals(testN)) {
      System.out.println("Test1.3.5 Fail");
    }

    testN.remove(n2);

    n2.setVisited(true);
    testN = new HashSet<Node>();
    if (!n3.unvisitedConnectingNodes().equals(testN)) {
      System.out.println("Test1.3.6 Fail");
    }

    testN = new HashSet<Node>();
    testN.add(n5);
    testN.add(n3);
    testN.add(n2);
    if (!n3.connectingNodes().equals(testN)) {
      System.out.println("Test1.3.7 Fail");
    }
    g1.setNodesVisited();

    // Edge visited flag testing

    HashSet<Edge> testE = new HashSet<Edge>();

    testE = new HashSet<Edge>();
    testE.add(e3);
    testE.add(e1);
    if (!n1.connectingEdges().equals(testE)) {
      System.out.println("Test1.5.1 Fail");
    }
    if (!n1.unvisitedConnectingEdges().equals(testE)) {
      System.out.println("Test1.5.2 Fail");
    }

    testE.remove(e1);
    e1.setVisited(true);
    if (!n1.unvisitedConnectingEdges().equals(testE)) {
      System.out.println("Test1.5.3 Fail");
    }
    e1.setVisited(false);
    e2.setVisited(false);

    g1.setEdgesVisited(true);
    testE = new HashSet<Edge>();
    if (!n1.unvisitedConnectingEdges().equals(testE)) {
      System.out.println("Test1.5.4 Fail");
    }
    e1.setVisited(true);
    e2.setVisited(true);
    g1.setEdgesVisited(false);
    testE = new HashSet<Edge>();
    testE.add(e3);
    testE.add(e1);
    if (!n1.connectingEdges().equals(testE)) {
      System.out.println("Test1.5.5 Fail");
    }
    if (!n1.unvisitedConnectingEdges().equals(testE)) {
      System.out.println("Test1.5.6 Fail");
    }

    System.out.print("Test 1 END");

    // test dynamic graph stuff
    System.out.println(" | Test 2 START: Object removal");
    Node nd1 = new Node("nd1");
    Node nd2 = new Node("nd2");
    Node nd3 = new Node("nd3");

    Graph g2 = new Graph("g2");
    g2.addNode(nd1);
    g2.addNode(nd2);
    g2.addNode(nd3);

    Edge ed1 = new Edge(nd1, nd2);
    Edge ed2 = new Edge(nd1, nd2);
    Edge ed3 = new Edge(nd2, nd1);
    Edge ed4 = new Edge(nd1, nd1);
    Edge ed5 = new Edge(nd3, nd2);
    g2.addEdge(ed1);
    g2.addEdge(ed2);
    g2.addEdge(ed3);
    g2.addEdge(ed4);
    g2.addEdge(ed5);

    g2.removeNode("nd1");

    ArrayList<Node> testNodeAL;
    ArrayList<Edge> testEdgeAL;
    testEdgeAL = new ArrayList<Edge>();
    testEdgeAL.add(ed5);
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.1 Fail");
    }
    g2.addNode(nd3);
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.2 Fail");
    }
    g2.removeNode(nd2);
    testEdgeAL = new ArrayList<Edge>();
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.3 Fail");
    }
    testNodeAL = new ArrayList<Node>();
    testNodeAL.add(nd3);
    if (!g2.getNodes().equals(testNodeAL)) {
      System.out.println("Test2.4 Fail");
    }
    testEdgeAL = new ArrayList<Edge>();
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.5 Fail");
    }

    if (!g2.consistent()) {
      System.out.println("Test2.5.0 Fail");
    }

    g2.clear();

    Node dyNode1 = new Node("dyNode1");
    Node dyNode2 = new Node("dyNode2");
    g2.addNode(dyNode1);
    g2.addNode(dyNode2);

    Edge dyEdge1 = new Edge(dyNode1, dyNode2, "dyEdge2");
    g2.addEdge(dyEdge1);

    g2.removeEdge(dyEdge1);

    if (dyEdge1.getFrom() != null) {
      System.out.println("Test2.5.1 Fail");
    }
    if (dyEdge1.getTo() != null) {
      System.out.println("Test2.5.2 Fail");
    }

    HashSet dyTest = new HashSet();

    if (dyNode1.getEdgesFrom().equals(dyTest) == false) {
      System.out.println("Test2.5.3 Fail");
    }
    if (dyNode1.getEdgesTo().equals(dyTest) == false) {
      System.out.println("Test2.5.4 Fail");
    }
    if (dyNode2.getEdgesFrom().equals(dyTest) == false) {
      System.out.println("Test2.5.5 Fail");
    }
    if (dyNode2.getEdgesTo().equals(dyTest) == false) {
      System.out.println("Test2.5.6 Fail");
    }
    if (!g2.consistent()) {
      System.out.println("Test2.5.7 Fail");
    }

    g2.clear();
    g2.addNode(nd1);
    g2.addNode(nd2);
    g2.addNode(nd3);

    ed1 = new Edge(nd1, nd2, "A", 1.1);
    ed2 = new Edge(nd1, nd2, "B");
    ed3 = new Edge(nd2, nd1, 1);
    ed4 = new Edge(nd1, nd1);
    ed5 = new Edge(nd3, nd2);
    g2.addEdge(ed1);
    g2.addEdge(ed2);
    g2.addEdge(ed3);
    g2.addEdge(ed4);
    g2.addEdge(ed5);

    // edge label and weight testing
    if (!ed1.getLabel().equals("A")) {
      System.out.println("Test2.5.1 Fail");
    }
    ed1.setLabel("C");
    if (!ed1.getLabel().equals("C")) {
      System.out.println("Test2.5.2 Fail");
    }
    if (!ed2.getLabel().equals("B")) {
      System.out.println("Test2.5.3 Fail");
    }
    if (ed1.getWeight() != 1.1) {
      System.out.println("Test2.5.4 Fail");
    }
    ed1.setWeight(2.2);
    if (ed1.getWeight() != 2.2) {
      System.out.println("Test2.5.5 Fail");
    }
    if (ed3.getWeight() != 1) {
      System.out.println("Test2.5.6 Fail");
    }

    g2.removeEdge(ed2);
    testEdgeAL = new ArrayList<Edge>();
    testEdgeAL.add(ed1);
    testEdgeAL.add(ed3);
    testEdgeAL.add(ed4);
    testEdgeAL.add(ed5);
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.6 Fail");
    }
    ArrayList<Node> testNodeAL2;

    testNodeAL2 = new ArrayList<Node>();
    testNodeAL2.add(nd1);
    testNodeAL2.add(nd2);
    testNodeAL2.add(nd3);
    if (!g2.getNodes().equals(testNodeAL2)) {
      System.out.println("Test2.7 Fail");
    }

    g2.removeEdge(ed4);

    testEdgeAL.remove(ed4);
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.8 Fail");
    }
    if (!g2.getNodes().equals(testNodeAL2)) {
      System.out.println("Test2.9 Fail");
    }

    ed4 = new Edge(nd3, nd3);
    g2.addEdge(ed4);
    testEdgeAL.add(ed4);
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.10 Fail");
    }
    if (!g2.getNodes().equals(testNodeAL2)) {
      System.out.println("Test2.11 Fail");
    }

    if (!g2.consistent()) {
      System.out.println("Test2.11.0 Fail");
    }

    g2.clear();

    testEdgeAL = new ArrayList<Edge>();
    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.12 Fail");
    }
    if (!g2.getNodes().equals(testEdgeAL)) {
      System.out.println("Test2.13 Fail");
    }

    ed4 = new Edge(nd2, nd1);
    g2.addNode(nd1);
    g2.addNode(nd2);
    g2.addNode(nd3);
    g2.addEdge(ed4);

    g2.removeEdge(ed4);

    if (!g2.getEdges().equals(testEdgeAL)) {
      System.out.println("Test2.14 Fail");
    }
    if (!g2.getNodes().equals(testNodeAL2)) {
      System.out.println("Test2.15 Fail");
    }

    if (!g2.consistent()) {
      System.out.println("Test2.15.0 Fail");
    }

    // score field testing
    Graph gScore = new Graph();

    Node ns1 = new Node("A");
    Node ns2 = new Node();
    Node ns3 = new Node("C");
    Node ns4 = new Node("D");

    gScore.addNode(ns1);
    gScore.addNode(ns2);
    gScore.addNode(ns3);
    gScore.addNode(ns4);

    Edge es1 = new Edge(ns1, ns2, "A", 1.1);
    Edge es2 = new Edge(ns4, ns1);
    Edge es3 = new Edge(ns1, ns3);

    gScore.addEdge(es1);
    gScore.addEdge(es2);
    gScore.addEdge(es3);

    if (ns1.getScore() != 0.0) {
      System.out.println("Test2.16.1 Fail");
    }

    if (es1.getScore() != 0.0) {
      System.out.println("Test2.16.2 Fail");
    }

    ns1.setScore(1.3);
    es1.setScore(2.4);

    if (ns1.getScore() != 1.3) {
      System.out.println("Test2.16.3 Fail");
    }

    if (es1.getScore() != 2.4) {
      System.out.println("Test2.16.4 Fail");
    }

    ArrayList<Node> alNodeScore = new ArrayList<Node>();
    ArrayList<Edge> alEdgeScore = new ArrayList<Edge>();
    gScore.setNodesScores(alNodeScore, 3.5);
    gScore.setEdgesScores(alEdgeScore, 4.6);

    if (ns1.getScore() != 1.3) {
      System.out.println("Test2.16.5 Fail");
    }

    if (es1.getScore() != 2.4) {
      System.out.println("Test2.16.6 Fail");
    }

    alNodeScore.add(ns1);
    alNodeScore.add(ns2);
    gScore.setNodesScores(alNodeScore, 5.7);
    alNodeScore.remove(ns1);
    alNodeScore.remove(ns2);
    alEdgeScore.add(es1);
    alEdgeScore.add(es2);
    gScore.setEdgesScores(alEdgeScore, 6.8);

    if (ns1.getScore() != 5.7) {
      System.out.println("Test2.16.7 Fail");
    }
    if (ns3.getScore() != 0.0) {
      System.out.println("Test2.16.8 Fail");
    }

    if (es1.getScore() != 6.8) {
      System.out.println("Test2.16.9 Fail");
    }
    if (es3.getScore() != 0.0) {
      System.out.println("Test2.16.10 Fail");
    }

    gScore.setNodesScores(7.9);
    gScore.setEdgesScores(8.01);

    if (ns1.getScore() != 7.9) {
      System.out.println("Test2.16.11 Fail");
    }
    if (ns3.getScore() != 7.9) {
      System.out.println("Test2.16.12 Fail");
    }

    if (es1.getScore() != 8.01) {
      System.out.println("Test2.16.13 Fail");
    }
    if (es3.getScore() != 8.01) {
      System.out.println("Test2.16.14 Fail");
    }

    Graph testChangeGraph = new Graph();

    if (testChangeGraph.moveNodeToEnd(n1)) {
      System.out.println("Test2.17.1 Fail");
    }
    if (testChangeGraph.moveEdgeToEnd(e1)) {
      System.out.println("Test2.17.2 Fail");
    }

    ArrayList<Node> testChangeNodeAL = new ArrayList<Node>();

    Node changeNode1 = new Node("c1");
    testChangeGraph.addNode(changeNode1);

    if (testChangeGraph.moveNodeToEnd(n1)) {
      System.out.println("Test2.17.3 Fail");
    }

    testChangeGraph.moveNodeToEnd(changeNode1);

    testChangeNodeAL = new ArrayList<Node>();
    testChangeNodeAL.add(changeNode1);

    if (!testChangeGraph.getNodes().equals(testChangeNodeAL)) {
      System.out.println("Test2.17.4 Fail");
    }

    Node changeNode2 = new Node("c2");
    Node changeNode3 = new Node("c3");

    Edge changeEdge1 = new Edge(changeNode1, changeNode2);
    Edge changeEdge2 = new Edge(changeNode3, changeNode2);
    Edge changeEdge3 = new Edge(changeNode1, changeNode3);

    testChangeGraph.addNode(changeNode2);
    testChangeGraph.addNode(changeNode3);

    testChangeGraph.addEdge(changeEdge1);
    testChangeGraph.addEdge(changeEdge2);
    testChangeGraph.addEdge(changeEdge3);

    testChangeNodeAL = new ArrayList<Node>();
    testChangeNodeAL.add(changeNode1);
    testChangeNodeAL.add(changeNode3);
    testChangeNodeAL.add(changeNode2);

    testChangeGraph.moveNodeToEnd(changeNode2);

    if (!testChangeGraph.getNodes().equals(testChangeNodeAL)) {
      System.out.println("Test2.17.5 Fail");
    }

    ArrayList<Edge> testChangeEdgeAL = new ArrayList<Edge>();
    testChangeEdgeAL.add(changeEdge2);
    testChangeEdgeAL.add(changeEdge3);
    testChangeEdgeAL.add(changeEdge1);

    testChangeGraph.moveEdgeToEnd(changeEdge1);

    if (!testChangeGraph.getEdges().equals(testChangeEdgeAL)) {
      System.out.println("Test2.17.6 Fail");
    }

    System.out.print("Test 2 END");

    System.out.println(" | Test 3 START: Shortest path");

    ArrayList<Node> path = new ArrayList<Node>();
    path.add(n5);
    path.add(n4);
    path.add(n1);
    if (!g1.unweightedShortest(n5, n1).equals(path)) {
      System.out.println("Test3.1 Fail");
    }
    path = new ArrayList<Node>();
    path.add(n3);
    if (!g1.unweightedShortest(n3, n3).equals(path)) {
      System.out.println("Test3.2 Fail");
    }
    if (g1.unweightedShortest(n4, n6) != null) {
      System.out.println("Test3.3 Fail");
    }

    System.out.print("Test 3 END");

    // Adjacency Edge Graph creation stuff

    System.out.println(" | Test 4 START: Adjacency Graph");

    // finding or adding a node from a label
    Node nA = g1.addAdjacencyNode("nA");
    testNodeAL = new ArrayList<Node>();
    testNodeAL.add(n1);
    testNodeAL.add(n2);
    testNodeAL.add(n3);
    testNodeAL.add(n4);
    testNodeAL.add(n5);
    testNodeAL.add(n6);
    testNodeAL.add(nA);
    if (!g1.getNodes().equals(testNodeAL)) {
      System.out.println("Test4.1 Fail");
    }

    if (g1.addAdjacencyNode("n2") != n2) {
      System.out.println("Test4.2 Fail");
    }
    if (!g1.getNodes().equals(testNodeAL)) {
      System.out.println("Test4.3 Fail");
    }

    Node nDuplicate = new Node("n1");
    g1.addNode(nDuplicate);
    if (g1.addAdjacencyNode("n1") != null) {
      System.out.println("Test4.4 Fail");
    }
    g1.removeNode(nDuplicate);

    if (!g1.consistent()) {
      System.out.println("Test4.4.0 Fail");
    }

    // adding an adjacency edge
    Edge eZ1 = g1.addAdjacencyEdge("n3", "n3");

    Edge[] tempArray = {e1, e2, e3, e4, e5, e6, e7, e8, e9, eZ1};
    ArrayList<Edge> testEdgeAL2 = new ArrayList<Edge>(Arrays.asList(tempArray));

    if (!g1.getEdges().equals(testEdgeAL2)) {
      System.out.println("Test4.5 Fail");
    }
    if (!g1.getNodes().equals(testNodeAL)) {
      System.out.println("Test4.6 Fail");
    }

    g1.addAdjacencyEdge("nB", "");
    if (g1.getNodes().size() != 8) {
      System.out.println("Test4.7 Fail");
    }

    Edge eZ3 = g1.addAdjacencyEdge("nB", "n1");

    Edge[] tempArray2 = {e1, e2, e3, e4, e5, e6, e7, e8, e9, eZ1, eZ3};
    testEdgeAL2 = new ArrayList<Edge>(Arrays.asList(tempArray2));

    if (!g1.getEdges().equals(testEdgeAL2)) {
      System.out.println("Test4.8 Fail");
    }

    g1.addAdjacencyEdge("", "");
    Edge eZ4 = g1.addAdjacencyEdge("nC", "nD");

    Edge[] tempArray3 = {e1, e2, e3, e4, e5, e6, e7, e8, e9, eZ1, eZ3, eZ4};
    testEdgeAL2 = new ArrayList<Edge>(Arrays.asList(tempArray3));

    if (!g1.getEdges().equals(testEdgeAL2)) {
      System.out.println("Test4.9 Fail");
    }
    if (g1.getNodes().size() != 10) {
      System.out.println("Test4.10 Fail");
    }

    System.out.print("Test 4 END");

    System.out.println(" | Test 5 START: Connected");

    if (g1.connected()) {
      System.out.println("Test5.1 Fail");
    }
    g1.addEdge(new Edge(nA, n6));
    if (g1.connected()) {
      System.out.println("Test5.2 Fail");
    }
    g1.addAdjacencyEdge("nA", "nD");
    g1.addAdjacencyEdge("nA", "n4");
    if (!g1.connected()) {
      System.out.println("Test5.3 Fail");
    }

    if (!g1.consistent()) {
      System.out.println("Test5.3.0 Fail");
    }

    Graph g4 = new Graph("g4");
    if (!g4.connected()) {
      System.out.println("Test5.4 Fail");
    }
    g4.addNode(new Node("z1"));
    if (!g4.connected()) {
      System.out.println("Test5.5 Fail");
    }
    g4.addNode(new Node("z2"));
    if (g4.connected()) {
      System.out.println("Test5.6 Fail");
    }
    g4.addAdjacencyEdge("z1", "z2");
    if (!g4.connected()) {
      System.out.println("Test5.7 Fail");
    }
    g4.addAdjacencyEdge("z2", "z3");
    if (!g4.connected()) {
      System.out.println("Test5.8 Fail");
    }
    g4.removeNode("z2");
    if (g4.connected()) {
      System.out.println("Test5.9 Fail");
    }

    System.out.print("Test 5 END");

    System.out.println(" | Test 6 START: Equality by label testing");

    Graph gc1 = new Graph("gc1");
    Graph gc2 = new Graph("gc2");

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.1 Fail");
    }

    gc1.addNode(new Node("A"));
    if (gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.2 Fail");
    }
    gc2.addNode(new Node("B"));

    if (gc2.equalsByNodeLabel(gc1)) {
      System.out.println("Test6.3 Fail");
    }

    gc2.addNode(new Node("A"));

    if (gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.4 Fail");
    }

    gc1.addNode(new Node("B"));

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.5 Fail");
    }

    gc1.addNode(new Node("C"));
    gc2.addNode(new Node("C"));

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.6 Fail");
    }

    gc1.addAdjacencyEdge("A", "B");

    if (gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.7 Fail");
    }

    gc2.addAdjacencyEdge("A", "B");

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.8 Fail");
    }

    gc1.addAdjacencyEdge("C", "B");
    gc2.addAdjacencyEdge("C", "B");

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.9 Fail");
    }

    gc1.addAdjacencyEdge("C", "A");
    gc2.addAdjacencyEdge("A", "C");

    if (gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.10 Fail");
    }

    // this test is two non isomorphic graphs for which the comparison succeeds.

    gc1.clear();
    gc2.clear();

    Node gcn1 = new Node("");
    Node gcn2 = new Node("");
    Node gcn3 = new Node("");
    Node gcn4 = new Node("");
    gc1.addNode(gcn1);
    gc1.addNode(gcn2);
    gc2.addNode(gcn3);
    gc2.addNode(gcn4);

    gc1.addEdge(new Edge(gcn1, gcn2));

    gc2.addEdge(new Edge(gcn3, gcn3));

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.11 Fail");
    }

    // dispite the equal labels these graphs are not equal due to the extra edge
    gc2.addEdge(new Edge(gcn4, gcn3));

    if (gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.12 Fail");
    }

    gc1.addEdge(new Edge(gcn1, gcn2));

    if (!gc1.equalsByNodeLabel(gc2)) {
      System.out.println("Test6.13 Fail");
    }

    if (!gc1.consistent()) {
      System.out.println("Test6.13.0 Fail");
    }

    System.out.print("Test 6 END");

    // Adjacency file testing. This test creates a file called test.adj
    // It will crash with an exception if it cant create the file.

    System.out.println(" | Test 7 START: Adjacency file - needs to read and write test.adj");

    g4.generateRandomGraph(10, 15);
    g4.saveAdjacencyFile("test.adj");
    Graph g5 = new Graph("g5");
    g5.loadAdjacencyFile("test.adj");

    if (!g4.equalsByNodeLabel(g5)) {
      System.out.println("Test7.1 Fail");
    }

    if (!g4.consistent()) {
      System.out.println("Test7.1.0 Fail");
    }
    if (!g5.consistent()) {
      System.out.println("Test7.1.1 Fail");
    }

    g4.clear();
    g4.saveAdjacencyFile("test.adj");
    g5.clear();
    g5.generateRandomGraph(10, 15);
    g4.loadAdjacencyFile("test.adj");
    if (g4.equalsByNodeLabel(g5)) {
      System.out.println("Test7.2 Fail");
    }
    g4.generateRandomGraph(20, 30);
    g4.addNode(n1);
    g4.saveAdjacencyFile("test.adj");
    g5.generateRandomGraph(10, 15);
    g5.loadAdjacencyFile("test.adj");
    g4.loadAdjacencyFile("test.adj");
    if (!g5.equalsByNodeLabel(g4)) {
      System.out.println("Test7.3 Fail");
    }
    g4.clear();
    g4.saveAdjacencyFile("test.adj");
    g4.addNode(n1);
    g4.loadAdjacencyFile("test.adj");
    if (!g4.equalsByNodeLabel(new Graph())) {
      System.out.println("Test7.4 Fail");
    }

    if (!g4.consistent()) {
      System.out.println("Test7.4.0 Fail");
    }

    System.out.print("Test 7 END");

    // partial node and edge access

    System.out.println(" | Test 8 START: visited and path fields");

    Graph g = new Graph();
    HashSet<Node> testa = new HashSet<Node>();
    HashSet<Node> testb = new HashSet<Node>();

    if (!g.unvisitedNodes().equals(testa)) {
      System.out.println("Test8.1 Fail");
    }
    if (!g.visitedNodes().equals(testb)) {
      System.out.println("Test8.2 Fail");
    }

    g.addNode(n1);
    g.addNode(n2);
    g.addNode(n3);
    g.addNode(n4);

    Edge eV1 = new Edge(n1, n2);
    Edge eV2 = new Edge(n3, n2);
    Edge eV3 = new Edge(n4, n4);

    testa.add(n1);
    testa.add(n2);
    testa.add(n3);
    testa.add(n4);

    if (!g.unvisitedNodes().equals(testa)) {
      System.out.println("Test8.5 Fail");
    }
    if (!g.visitedNodes().equals(testb)) {
      System.out.println("Test8.6 Fail");
    }

    n1.setVisited(true);
    n2.setVisited(true);

    testa.remove(n1);
    testa.remove(n2);

    testb.add(n1);
    testb.add(n2);

    if (!g.unvisitedNodes().equals(testa)) {
      System.out.println("Test8.9 Fail");
    }
    if (!g.visitedNodes().equals(testb)) {
      System.out.println("Test8.10 Fail");
    }

    HashSet<Edge> teste1 = new HashSet<Edge>();
    HashSet<Edge> teste2 = new HashSet<Edge>();

    if (!g.unvisitedEdges().equals(teste1)) {
      System.out.println("Test8.13 Fail");
    }
    if (!g.visitedEdges().equals(teste2)) {
      System.out.println("Test8.14 Fail");
    }

    g.addEdge(eV1);
    g.addEdge(eV2);
    g.addEdge(eV3);

    eV1.setVisited(true);
    eV2.setVisited(true);
    eV3.setVisited(true);

    teste2.add(eV1);
    teste2.add(eV2);
    teste2.add(eV3);

    if (!g.unvisitedEdges().equals(teste1)) {
      System.out.println("Test8.15 Fail");
    }
    if (!g.visitedEdges().equals(teste2)) {
      System.out.println("Test8.16 Fail");
    }

    eV3.setVisited(false);

    teste1.add(eV3);
    teste2.remove(eV3);

    if (!g.unvisitedEdges().equals(teste1)) {
      System.out.println("Test8.17 Fail");
    }
    if (!g.visitedEdges().equals(teste2)) {
      System.out.println("Test8.18 Fail");
    }

    System.out.print("Test 8 END");

    // euler tour tests
    System.out.println(" | Test 9 START: Euler Tour - needs to read and write test.euler");

    Graph eg = new Graph();
    ArrayList<Node> tour1 = new ArrayList<Node>();
    eg.saveTour("test.euler", tour1);
    ArrayList<Node> tour2 = eg.loadTour("test.euler");
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.1 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2.add(n1);
    if (eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.2 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    eg.saveTour("test.euler", tour1, false);
    tour2 = eg.loadTour("test.euler");
    if (eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.3 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }

    eg = new Graph();
    eg.generateRandomEulerGraph(5, 7);
    tour1 = eg.euler();
    eg.saveTour("test.euler", tour1);
    tour2 = eg.loadTour("test.euler");
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.4 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(false);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.4a Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(true);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.4b Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2.remove(2);
    if (eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.5 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    eg.addAdjacencyEdge("1", "2");
    eg.saveTour("test.euler", tour1, false);
    tour2 = eg.loadTour("test.euler");
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.6 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }

    if (!eg.consistent()) {
      System.out.println("Test 9.6.0 Fail");
    }

    eg.clear();
    eg.addNode(n1);
    tour1 = eg.euler();
    tour2 = new ArrayList<Node>();
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.6.1 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    eg.generateRandomEulerGraph(2, 4);
    tour1 = eg.euler();
    eg.saveTour("test.euler", tour1);
    tour2 = eg.loadTour("test.euler");
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.7 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(false);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.7a Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(true);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.7b Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = new ArrayList<Node>();
    if (eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.8 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    eg.addNode(new Node());
    eg.saveTour("test.euler", tour1, false);
    tour2 = eg.loadTour("test.euler");
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.9 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }

    if (!eg.consistent()) {
      System.out.println("Test 9.9.0 Fail");
    }

    eg = new Graph();
    eg.generateRandomEulerGraph(20, 30);
    tour2 = eg.euler();
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.10 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(false);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.10a Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(true);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.10b Failed with tour " + tour2 + "\nand graph\n" + eg);
    }

    if (!eg.consistent()) {
      System.out.println("Test 9.10.0 Fail");
    }

    Node nX0 = new Node("0");
    Node nX1 = new Node("1");
    Node nX2 = new Node("2");
    Node nX3 = new Node("3");
    Node nX4 = new Node("4");
    eg = new Graph();
    eg.addNode(nX0);
    eg.addNode(nX1);
    eg.addNode(nX2);
    eg.addNode(nX3);
    eg.addNode(nX4);
    eg.addEdge(new Edge(nX0, nX1));
    eg.addEdge(new Edge(nX3, nX2));
    eg.addEdge(new Edge(nX4, nX2));
    eg.addEdge(new Edge(nX0, nX1));
    eg.addEdge(new Edge(nX3, nX0));
    eg.addEdge(new Edge(nX0, nX3));
    eg.addEdge(new Edge(nX3, nX4));
    tour2 = eg.euler();
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.11 Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(false);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.11a Failed with tour " + tour2 + "\nand graph\n" + eg);
    }
    tour2 = eg.eulerSMK(true);
    if (!eg.eulerTourInGraph(tour2)) {
      System.out.println("Test 9.11b Failed with tour " + tour2 + "\nand graph\n" + eg);
    }

    System.out.print("Test 9 END");

    // test the brute force tsp
    System.out.println(" | Test 10 START: tsp");

    Graph tspGraph = new Graph();

    ArrayList<Edge> tspTest = new ArrayList<Edge>();

    if (!tspGraph.tsp().equals(tspTest)) {
      System.out.println("Test 10.1 Failed");
    }

    Node tspN1 = new Node("A");
    tspGraph.addNode(tspN1);

    if (!tspGraph.tsp().equals(tspTest)) {
      System.out.println("Test 10.2 Failed");
    }

    Node tspN2 = new Node("B");
    tspGraph.addNode(tspN2);

    Edge tspE1 = new Edge(tspN1, tspN2, 2);

    tspGraph.addEdge(tspE1);

    tspTest.add(tspE1);
    tspTest.add(tspE1);

    if (!tspGraph.tsp().equals(tspTest)) {
      System.out.println("Test 10.3 Failed");
    }
    if (tspGraph.sumEdgeWeights(tspGraph.tsp()) != 4.0) {
      System.out.println("Test 10.4 Failed");
    }

    Node tspN3 = new Node("C");
    tspGraph.addNode(tspN3);

    Edge tspE2 = new Edge(tspN1, tspN3, 40);
    Edge tspE3 = new Edge(tspN2, tspN3, 3);

    tspGraph.addEdge(tspE2);
    tspGraph.addEdge(tspE3);

    if (tspGraph.sumEdgeWeights(tspGraph.tsp()) != 10.0) {
      System.out.println("Test 10.5 Failed");
    }

    tspE2.setWeight(4);

    if (tspGraph.sumEdgeWeights(tspGraph.tsp()) != 9.0) {
      System.out.println("Test 10.6 Failed");
    }

    Node tspN4 = new Node("D");
    tspGraph.addNode(tspN4);

    tspGraph.addEdge(new Edge(tspN1, tspN4, 3.5));
    tspGraph.addEdge(new Edge(tspN2, tspN4, 6));
    tspGraph.addEdge(new Edge(tspN4, tspN3, 2.4));

    if (tspGraph.sumEdgeWeights(tspGraph.tsp()) != 10.9) {
      System.out.println("Test 10.7 Failed");
    }

    tspGraph.clear();

    tspGraph.addAdjacencyEdge("A", "H", 17.0);
    tspGraph.addAdjacencyEdge("G", "H", 1.0);
    tspGraph.addAdjacencyEdge("H", "E", 2);
    tspGraph.addAdjacencyEdge("G", "E", 9.0);
    tspGraph.addAdjacencyEdge("E", "D", 20.0);
    tspGraph.addAdjacencyEdge("C", "D", 2.5);
    tspGraph.addAdjacencyEdge("C", "B", 3.0);
    tspGraph.addAdjacencyEdge("D", "B", 4.0);

    if (tspGraph.sumEdgeWeights(tspGraph.tsp()) != 89.5) {
      System.out.println("Test 10.8 Failed");
    }

    tspGraph.clear();

    tspGraph.addAdjacencyEdge("A", "H", "17", 17.0);
    tspGraph.addAdjacencyEdge("G", "H", "1", 1.0);
    tspGraph.addAdjacencyEdge("G", "A", "1", 1.0);
    tspGraph.addAdjacencyEdge("E", "D", "20", 20.0);
    tspGraph.addAdjacencyEdge("C", "D", "2 and a half", 2.5);
    tspGraph.addAdjacencyEdge("C", "B", "3", 3.0);
    tspGraph.addAdjacencyEdge("D", "B", "4", 4.0);

    if (tspGraph.tsp() != null) {
      System.out.println("Test 10.9 Failed");
    }

    System.out.print("Test 10 END");

    System.out.println(" | Test 11 START: Union Find");

    UnionFind uf = new UnionFind(10);

    if (uf.find(9, 4)) {
      System.out.println("Test 11.1 Fail");
    }

    uf.union(1, 2);
    if (uf.getParent()[1] != 2) {
      System.out.println("Test 11.2 Fail");
    }
    if (uf.getParent()[2] != uf.ROOT) {
      System.out.println("Test 11.3 Fail");
    }

    uf.union(3, 2);
    if (!uf.find(3, 2)) {
      System.out.println("Test 11.4 Fail");
    }
    if (uf.find(3, 7)) {
      System.out.println("Test 11.5 Fail");
    }
    if (uf.find(7, 3)) {
      System.out.println("Test 11.6 Fail");
    }
    uf.union(5, 4);
    if (!uf.find(5, 4)) {
      System.out.println("Test 11.7 Fail");
    }
    if (uf.find(3, 4)) {
      System.out.println("Test 11.8 Fail");
    }
    if (uf.find(5, 7)) {
      System.out.println("Test 11.9 Fail");
    }
    uf.union(3, 4);
    if (!uf.find(3, 4)) {
      System.out.println("Test 11.10 Fail");
    }
    uf.union(4, 1);
    if (!uf.find(4, 3)) {
      System.out.println("Test 11.11 Fail");
    }
    uf.union(7, 6);
    uf.union(8, 9);
    uf.union(8, 7);
    if (uf.find(7, 2)) {
      System.out.println("Test 11.12 Fail");
    }
    uf.union(8, 4);
    if (!uf.find(7, 2)) {
      System.out.println("Test 11.13 Fail");
    }
    if (uf.find(7, 10)) {
      System.out.println("Test 11.12 Fail");
    }
    System.out.print("Test 11 END");

    System.out.println(" | Test 12 START: mst");

    Graph mstGraph = new Graph();

    // generating a complete graph
    mstGraph.generateCompleteGraph(0);
    if (mstGraph.getNodes().size() != 0) {
      System.out.println("Test12.1.1 Fail");
    }
    if (mstGraph.getEdges().size() != 0) {
      System.out.println("Test12.1.2 Fail");
    }

    mstGraph.generateCompleteGraph(1);
    if (mstGraph.getNodes().size() != 1) {
      System.out.println("Test12.1.3 Fail");
    }
    if (mstGraph.getEdges().size() != 0) {
      System.out.println("Test12.1.4 Fail");
    }

    if (!mstGraph.consistent()) {
      System.out.println("Test 12.1.4.0 Fail");
    }

    mstGraph.generateCompleteGraph(5);
    if (mstGraph.getNodes().size() != 5) {
      System.out.println("Test12.1.5 Fail");
    }
    if (mstGraph.getEdges().size() != 10) {
      System.out.println("Test12.1.6 Fail");
    }

    mstGraph.generateCompleteGraph(8);
    if (mstGraph.getNodes().size() != 8) {
      System.out.println("Test12.1.7 Fail");
    }
    if (mstGraph.getEdges().size() != 28) {
      System.out.println("Test12.1.8 Fail");
    }

    mstGraph.setEdgesWeights(1.0);
    if (mstGraph.sumEdgeWeights(mstGraph.prim()) != 7) {
      System.out.println("Test12.2.1 Fail");
    }
    if (mstGraph.sumEdgeWeights(mstGraph.kruskal()) != 7) {
      System.out.println("Test12.2.2 Fail");
    }

    mstGraph.clear();

    ArrayList<Edge> mstCompare = new ArrayList<Edge>();

    if (!mstCompare.equals(mstGraph.prim())) {
      System.out.println("Test12.2.3 Fail");
    }
    if (!mstCompare.equals(mstGraph.kruskal())) {
      System.out.println("Test12.2.4 Fail");
    }

    Node mstN1 = new Node("A");
    Node mstN2 = new Node("B");
    Node mstN3 = new Node("C");

    mstGraph.addNode(mstN1);

    if (!mstCompare.equals(mstGraph.prim())) {
      System.out.println("Test12.2.5 Fail");
    }
    if (!mstCompare.equals(mstGraph.kruskal())) {
      System.out.println("Test12.2.6 Fail");
    }

    mstGraph.addNode(mstN2);

    if (mstGraph.prim() != null) {
      System.out.println("Test12.2.7 Fail");
    }
    if (mstGraph.kruskal() != null) {
      System.out.println("Test12.2.8 Fail");
    }

    Edge mstE1 = new Edge(mstN1, mstN2, "A", 1);

    mstGraph.addEdge(mstE1);

    mstCompare.add(mstE1);
    if (!mstCompare.equals(mstGraph.prim())) {
      System.out.println("Test12.2.9 Fail");
    }
    if (!mstCompare.equals(mstGraph.kruskal())) {
      System.out.println("Test12.2.10 Fail");
    }

    mstGraph.addNode(mstN3);
    Edge mstE2 = new Edge(mstN2, mstN3, "B", 5);
    Edge mstE3 = new Edge(mstN3, mstN1, "C", 2);
    Edge mstE4 = new Edge(mstN2, mstN2, "D", 1);

    mstGraph.addEdge(mstE2);
    mstGraph.addEdge(mstE3);
    mstGraph.addEdge(mstE4);

    mstCompare.add(mstE3);

    if (mstGraph.sumEdgeWeights(mstGraph.prim()) != 3) {
      System.out.println("Test12.2.11 Fail");
    }
    if (mstGraph.sumEdgeWeights(mstGraph.kruskal()) != 3) {
      System.out.println("Test12.2.12 Fail");
    }

    // generated graph test - randomly generate graphs of size
    // 1-10 nodes, edges 4-14, and compare prim against kruskal
    // on test fail, the graph should be printed for reference.
    for (int i = 1; i <= 10; i++) {

      mstGraph.generateRandomGraph(i, i + 3);
      mstGraph.randomlyWeightGraph(0, 100);

      ArrayList<Edge> prim = mstGraph.prim();
      double primSum = 0;
      if (prim != null) {
        primSum = mstGraph.sumEdgeWeights(prim);
      }
      ArrayList<Edge> kruskal = mstGraph.kruskal();
      double kruskalSum = 0;
      if (kruskal != null) {
        kruskalSum = mstGraph.sumEdgeWeights(kruskal);
      }

      if (primSum != kruskalSum) {
        System.out.println("Test 12.3." + i + " Failed - mst sums not equal");
        System.out.println("Randomly Generated Graph");
        System.out.println(mstGraph);
      }

      if (!mstGraph.consistent()) {
        System.out.println("Test 12.3." + i + ".0 Failed - graph consistency check failed");
        System.out.println("Randomly Generated Graph");
        System.out.println(mstGraph);
      }
    }

    System.out.print("Test 12 END");

    // test the types
    System.out.println(" | Test 13 START: Node and Edge Types");

    NodeType nt11 = new NodeType("nt11");
    NodeType nt21 = new NodeType("nt21");
    NodeType nt31 = new NodeType("nt31");
    NodeType nt22 = new NodeType("nt22");
    NodeType nt32 = new NodeType("nt32");
    NodeType nt33 = new NodeType("nt33");
    NodeType nt34 = new NodeType("nt34");
    NodeType nt23 = new NodeType("nt23");
    NodeType nt41 = new NodeType("nt41");
    NodeType nt42 = new NodeType("nt42");
    NodeType nt43 = new NodeType("nt43");
    nt21.setParent(nt11);
    nt31.setParent(nt21);
    nt22.setParent(nt11);
    nt32.setParent(nt21);
    nt33.setParent(nt22);
    nt34.setParent(nt21);
    nt23.setParent(nt11);
    nt41.setParent(nt32);
    nt42.setParent(nt32);
    nt43.setParent(nt32);

    nt22.removeParent();
    NodeType ntmove = (NodeType) nt33.getParent();
    nt32.setParent(ntmove);

    if (nt11.setParent(nt31)) {
      System.out.println("Test 13.3.1 FAIL");
    }
    if (!nt11.setParent(nt43)) {
      System.out.println("Test 13.3.2 FAIL");
    }

    if (nt43.setParent(nt43)) {
      System.out.println("Test 13.3.3 FAIL");
    }

    if (nt43.setParent(nt43)) {
      System.out.println("Test 13.3.4 FAIL");
    }

    if (!nt43.ancestor(nt32)) {
      System.out.println("Test 13.3.5 FAIL");
    }
    if (nt41.ancestor(nt41)) {
      System.out.println("Test 13.3.6 FAIL");
    }
    if (!nt33.ancestor(nt22)) {
      System.out.println("Test 13.3.7 FAIL");
    }
    if (nt41.ancestor(nt42)) {
      System.out.println("Test 13.3.8 FAIL");
    }

    if (nt41.root() != nt22) {
      System.out.println("Test 13.3.9 FAIL");
    }
    if (nt22.root() != nt22) {
      System.out.println("Test 13.3.10 FAIL");
    }

    EdgeType et11 = new EdgeType("et11");
    EdgeType et21 = new EdgeType("et21");
    EdgeType et22 = new EdgeType("et22");
    EdgeType et31 = new EdgeType("et31");
    et21.setParent(et11);
    et31.setParent(et22);
    et22.setParent(et11);
    et21.setDirected(true);

    if (!et31.ancestor(et11)) {
      System.out.println("Test 13.4.1 FAIL");
    }
    if (et11.ancestor(et21)) {
      System.out.println("Test 13.4.2 FAIL");
    }
    if (et21.root() != et11) {
      System.out.println("Test 13.4.3 FAIL");
    }
    if (et11.root() != et11) {
      System.out.println("Test 13.4.4 FAIL");
    }

    Node nt1 = new Node("nt1", new Point(100, 100));
    Node nt2 = new Node("nt2", nt32, new Point(110, 100));
    Node nt3 = new Node("nt3", nt11, new Point(200, 200));

    Edge et1 = new Edge(nt1, nt2, "e1", 3.0, et11);
    Edge et2 = new Edge(nt2, nt3, "e2");
    Edge et3 = new Edge(nt1, nt3, "e3", 0.0, et31);

    Graph gt = new Graph("gt1");

    gt.addNode(nt1);
    gt.addNode(nt2);
    gt.addNode(nt3);
    gt.addEdge(et1);
    gt.addEdge(et2);
    gt.addEdge(et3);

    if (nt1.getType() != Graph.DEFAULT_NODE_TYPE) {
      System.out.println("Test 13.5.1 FAIL");
    }

    if (nt2.getType() != nt32) {
      System.out.println("Test 13.5.2 FAIL");
    }

    nt2.setType(nt41);

    if (nt2.getType() != nt41) {
      System.out.println("Test 13.5.3 FAIL");
    }

    if (et2.getType() != Graph.DEFAULT_EDGE_TYPE) {
      System.out.println("Test 13.5.4 FAIL");
    }

    if (et3.getType() != et31) {
      System.out.println("Test 13.5.5 FAIL");
    }

    et3.setType(Graph.DEFAULT_EDGE_TYPE);

    if (et3.getType() != Graph.DEFAULT_EDGE_TYPE) {
      System.out.println("Test 13.5.7 FAIL");
    }

    if (Graph.DEFAULT_EDGE_TYPE.root() != Graph.DEFAULT_EDGE_TYPE) {
      System.out.println("Test 13.5.8 FAIL");
    }

    System.out.println("Test 13 END");

    System.out.println("End Graph Tests");
  }
コード例 #24
0
  /**
   * Transforms a DAG represented in graph <code>graph</code> into a maximally directed pattern
   * (PDAG) by modifying <code>g</code> itself. Based on the algorithm described in Chickering
   * (2002) "Optimal structure identification with greedy search" Journal of Machine Learning
   * Research. It works for both BayesNets and SEMs. R. Silva, June 2004
   */
  public static void dagToPdag(Graph graph) {
    // do topological sort on the nodes
    Graph graphCopy = new EdgeListGraph(graph);
    Node orderedNodes[] = new Node[graphCopy.getNodes().size()];
    int count = 0;
    while (graphCopy.getNodes().size() > 0) {
      Set<Node> exogenousNodes = new HashSet<Node>();

      for (Node next : graphCopy.getNodes()) {
        if (graphCopy.isExogenous(next)) {
          exogenousNodes.add(next);
          orderedNodes[count++] = graph.getNode(next.getName());
        }
      }

      graphCopy.removeNodes(new ArrayList<Node>(exogenousNodes));
    }
    // ordered edges - improvised, inefficient implementation
    count = 0;
    Edge edges[] = new Edge[graph.getNumEdges()];
    boolean edgeOrdered[] = new boolean[graph.getNumEdges()];
    Edge orderedEdges[] = new Edge[graph.getNumEdges()];

    for (Edge edge : graph.getEdges()) {
      edges[count++] = edge;
    }

    for (int i = 0; i < edges.length; i++) {
      edgeOrdered[i] = false;
    }

    while (count > 0) {
      for (Node orderedNode : orderedNodes) {
        for (int k = orderedNodes.length - 1; k >= 0; k--) {
          for (int q = 0; q < edges.length; q++) {
            if (!edgeOrdered[q]
                && edges[q].getNode1() == orderedNodes[k]
                && edges[q].getNode2() == orderedNode) {
              edgeOrdered[q] = true;
              orderedEdges[orderedEdges.length - count] = edges[q];
              count--;
            }
          }
        }
      }
    }

    // label edges
    boolean compelledEdges[] = new boolean[graph.getNumEdges()];
    boolean reversibleEdges[] = new boolean[graph.getNumEdges()];
    for (int i = 0; i < graph.getNumEdges(); i++) {
      compelledEdges[i] = false;
      reversibleEdges[i] = false;
    }
    for (int i = 0; i < graph.getNumEdges(); i++) {
      if (compelledEdges[i] || reversibleEdges[i]) {
        continue;
      }
      Node x = orderedEdges[i].getNode1();
      Node y = orderedEdges[i].getNode2();
      for (int j = 0; j < orderedEdges.length; j++) {
        if (orderedEdges[j].getNode2() == x && compelledEdges[j]) {
          Node w = orderedEdges[j].getNode1();
          if (!graph.isParentOf(w, y)) {
            for (int k = 0; k < orderedEdges.length; k++) {
              if (orderedEdges[k].getNode2() == y) {
                compelledEdges[k] = true;
                break;
              }
            }
          } else {
            for (int k = 0; k < orderedEdges.length; k++) {
              if (orderedEdges[k].getNode1() == w && orderedEdges[k].getNode2() == y) {
                compelledEdges[k] = true;
                break;
              }
            }
          }
        }
        if (compelledEdges[i]) {
          break;
        }
      }
      if (compelledEdges[i]) {
        continue;
      }
      boolean foundZ = false;

      for (Edge orderedEdge : orderedEdges) {
        Node z = orderedEdge.getNode1();
        if (z != x && orderedEdge.getNode2() == y && !graph.isParentOf(z, x)) {
          compelledEdges[i] = true;
          for (int k = i + 1; k < graph.getNumEdges(); k++) {
            if (orderedEdges[k].getNode2() == y && !reversibleEdges[k]) {
              compelledEdges[k] = true;
            }
          }
          foundZ = true;
          break;
        }
      }

      if (!foundZ) {
        reversibleEdges[i] = true;

        for (int j = i + 1; j < orderedEdges.length; j++) {
          if (!compelledEdges[j] && orderedEdges[j].getNode2() == y) {
            reversibleEdges[j] = true;
          }
        }
      }
    }

    // undirect edges that are reversible
    for (int i = 0; i < reversibleEdges.length; i++) {
      if (reversibleEdges[i]) {
        graph.setEndpoint(orderedEdges[i].getNode1(), orderedEdges[i].getNode2(), Endpoint.TAIL);
        graph.setEndpoint(orderedEdges[i].getNode2(), orderedEdges[i].getNode1(), Endpoint.TAIL);
      }
    }
  }
コード例 #25
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
 private boolean isTwoCycle(Graph graph, Node x, Node y) {
   List<Edge> edges = graph.getEdges(x, y);
   return edges.size() == 2;
 }
コード例 #26
0
ファイル: DJAlgorithm.java プロジェクト: nerdymech/cs509
 public DJAlgorithm(Graph graph) {
   this.nodes = new ArrayList<Vertex>(graph.getVertexes());
   this.edges = new ArrayList<Edges>(graph.getEdges());
 }
コード例 #27
0
ファイル: GesConcurrent.java プロジェクト: renjiey/tetrad
  private void addRequiredEdges(Graph graph) {
    if (true) return;
    if (knowledgeEmpty()) return;

    for (Iterator<KnowledgeEdge> it = getKnowledge().requiredEdgesIterator(); it.hasNext(); ) {
      KnowledgeEdge next = it.next();

      Node nodeA = graph.getNode(next.getFrom());
      Node nodeB = graph.getNode(next.getTo());

      if (!graph.isAncestorOf(nodeB, nodeA)) {
        graph.removeEdges(nodeA, nodeB);
        graph.addDirectedEdge(nodeA, nodeB);
        TetradLogger.getInstance()
            .log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeA, nodeB));
      }
    }
    for (Edge edge : graph.getEdges()) {
      final String A = edge.getNode1().getName();
      final String B = edge.getNode2().getName();

      if (knowledge.isForbidden(A, B)) {
        Node nodeA = edge.getNode1();
        Node nodeB = edge.getNode2();

        if (nodeA != null
            && nodeB != null
            && graph.isAdjacentTo(nodeA, nodeB)
            && !graph.isChildOf(nodeA, nodeB)) {
          if (!graph.isAncestorOf(nodeA, nodeB)) {
            graph.removeEdges(nodeA, nodeB);
            graph.addDirectedEdge(nodeB, nodeA);
            TetradLogger.getInstance()
                .log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
          }
        }
        if (!graph.isChildOf(nodeA, nodeB)
            && getKnowledge().isForbidden(nodeA.getName(), nodeB.getName())) {
          if (!graph.isAncestorOf(nodeA, nodeB)) {
            graph.removeEdges(nodeA, nodeB);
            graph.addDirectedEdge(nodeB, nodeA);
            TetradLogger.getInstance()
                .log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
          }
        }
      } else if (knowledge.isForbidden(B, A)) {
        Node nodeA = edge.getNode2();
        Node nodeB = edge.getNode1();

        if (nodeA != null
            && nodeB != null
            && graph.isAdjacentTo(nodeA, nodeB)
            && !graph.isChildOf(nodeA, nodeB)) {
          if (!graph.isAncestorOf(nodeA, nodeB)) {
            graph.removeEdges(nodeA, nodeB);
            graph.addDirectedEdge(nodeB, nodeA);
            TetradLogger.getInstance()
                .log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
          }
        }
        if (!graph.isChildOf(nodeA, nodeB)
            && getKnowledge().isForbidden(nodeA.getName(), nodeB.getName())) {
          if (!graph.isAncestorOf(nodeA, nodeB)) {
            graph.removeEdges(nodeA, nodeB);
            graph.addDirectedEdge(nodeB, nodeA);
            TetradLogger.getInstance()
                .log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
          }
        }
      }
    }
  }