public Node commonAncestor(Node one, Node two) {
    // Implementation here

    HashSet<Node> pathHash = new HashSet<>();
    Node currentOne = one;

    if (one == null || two == null) {
      return null;
    }

    while (!currentOne.isRoot()) {
      pathHash.add(currentOne);
      currentOne = currentOne.parent;
    }

    pathHash.add(currentOne);

    Node currentTwo = two;
    while (!currentTwo.isRoot()) {
      if (pathHash.contains(currentTwo)) {
        return currentTwo;
      }
      currentTwo = currentTwo.parent;
    }

    if (pathHash.contains(currentTwo)) {
      return currentTwo;
    }

    return null;
  }
Exemple #2
0
 private Node search(Node node, int key) {
   if (key == node.getKey()) {
     return node;
   } else if (key > node.getKey()) {
     return search(node.getRight(), key);
   } else {
     return search(node.getLeft(), key);
   }
 }
Exemple #3
0
  private Node locateNewNodeParent(Node currentNodeentNode, int key) {

    if (key > currentNodeentNode.getKey()) {
      if (currentNodeentNode.getRight() == nil) return currentNodeentNode;
      else return locateNewNodeParent(currentNodeentNode.getRight(), key);
    } else {
      if (currentNodeentNode.getLeft() == nil) return currentNodeentNode;
      else return locateNewNodeParent(currentNodeentNode.getLeft(), key);
    }
  }
Exemple #4
0
  public void insert(int key) {

    if (root == null) root = new Node(key);
    else {
      Node parent = locateNewNodeParent(root, key);
      Node node = new Node(parent, key);
      if (key > parent.getKey()) node.getParent().setRight(node);
      else node.getParent().setLeft(node);
      afterInsert(node);
    }
  }
Exemple #5
0
  public void print() {

    Node marker = new Node();
    Node emptyNode = new Node();

    Queue<Node> queue = new ArrayBlockingQueue<Node>(1000);

    queue.offer(root);
    queue.offer(marker);
    while (!queue.isEmpty()) {
      Node currentNode = queue.poll();
      if (currentNode == marker && !queue.isEmpty()) {
        queue.offer(marker);
        System.out.println("");
      } else {
        if (currentNode == emptyNode) {
          System.out.print(" - ");
        } else {
          if (currentNode != marker) {
            String print = "  " + currentNode.getKey() + "  ";
            if (currentNode.isRed()) print = " <" + currentNode.getKey() + "> ";
            System.out.print(print);
          }
          if (currentNode.getLeft() == null) queue.offer(emptyNode);
          else queue.offer(currentNode.getLeft());

          if (currentNode.getRight() == null) queue.offer(emptyNode);
          else queue.offer(currentNode.getRight());
        }
      }
    }
  }
Exemple #6
0
  private Node getSuccessor(Node node) {

    if (node.getLeft() != null && node.getLeft() != nil) return minNode(node.getRight());
    Node parent = node.getParent();

    while (parent != nil && node == parent.getRight()) {
      node = parent;
      parent = parent.getParent();
    }

    return parent;
  }
Exemple #7
0
  private void afterDelete(Node node) {

    while (node != root && node.isBlack()) {
      if (node.isLeft()) {

        Node sibling = node.getParent().getRight();
        if (sibling.isRed()) {
          Node parent;
          sibling.setColor(BLACK);
          node.getParent().setColor(RED);
          parent =
              // rotateLeft(node.getParent());
              rotateLeft(node.getParent());
          // sibling = node.getParent().getRight();
          sibling = parent.getRight();
        }
        if (sibling.getLeft() != null
            && sibling.getRight() != null
            && sibling.getLeft().isBlack()
            && sibling.getRight().isBlack()) {
          sibling.setColor(RED);
          node = node.getParent();
        } else if (sibling.getRight() != null && sibling.getRight().isBlack()) {
          sibling.getLeft().setColor(BLACK);
          sibling.setColor(RED);
          rotateRight(sibling);
          // sibling = node.getParent().getRight();
          sibling = node.getRight();
        }

        sibling.setColor(node.getParent().getColor());
        node.getParent().setColor(BLACK);
        if (sibling.getRight() != null) sibling.getRight().setColor(BLACK);
        rotateLeft(node.getParent());
        node = root;

      } else {
        Node parent = null;
        Node sibling = node.getParent().getLeft();
        if (sibling.isRed()) {

          sibling.setColor(BLACK);
          node.getParent().setColor(RED);
          parent = rotateRight(node.getParent());
          // rotateRight(node.getParent());
          // sibling = node.getParent().getLeft();
          sibling = parent.getLeft();
        }
        if (sibling.getLeft() != null
            && sibling.getRight() != null
            && sibling.getLeft().isBlack()
            && sibling.getRight().isBlack()) {
          sibling.setColor(RED);
          // node = node.getParent();
          node = parent;
        } else if (sibling.getLeft() != null && sibling.getLeft().isBlack()) {

          sibling.getRight().setColor(BLACK);
          sibling.setColor(RED);
          // sibling =
          rotateLeft(sibling);
          // sibling = node.getParent().getLeft();
          sibling = parent.getLeft();
        }

        if (node.getParent() == null) sibling.setColor(BLACK);
        else sibling.setColor(node.getParent().getColor());
        if (node.getParent() != null) node.getParent().setColor(BLACK);
        if (sibling.getLeft() != null) sibling.getLeft().setColor(BLACK);
        rotateRight(node.getParent());
        node = root;
      }
    }
    node.setColor(BLACK);
  }
Exemple #8
0
 private Node minNode(Node node) {
   while (node.getLeft() != null && node.getLeft() != nil) node = node.getLeft();
   return node;
 }
Exemple #9
0
  public void delete(int key) {

    Node node = search(key);

    Node tempNode = nil;
    Node successor = nil;

    if (node.getLeft() == nil || node.getRight() == nil) successor = node;
    else successor = getSuccessor(node);

    if (successor.getLeft() != nil) tempNode = successor.left;
    else tempNode = successor.right;

    tempNode.parent = successor.parent;

    if (successor.getParent() == null) root = tempNode;
    else if (successor.getParent().getLeft() != nil && successor.parent.left == successor)
      successor.parent.left = tempNode;
    else if (successor.getParent().getRight() != nil && successor.parent.right == successor)
      successor.parent.right = tempNode;

    if (successor != node) {
      node.key = successor.key;
    }

    if (successor.getColor() == BLACK) afterDelete(tempNode);
  }
Exemple #10
0
  private Node rotateRight(Node node) {

    if (node == root) {
      root = node.getLeft();
      Node right = node.getLeft().getRight();

      right.setParent(node);
      root.setParent(null);
      node.setLeft(right);

      root.setRight(node);
      node.setParent(root);

    } else {
      Node parent = node.getParent();

      node.setParent(parent.getParent());
      if (parent == root) {
        root = node;
        root.setParent(null);
      } else {

        if (parent.isLeft()) parent.getParent().setLeft(node);
        else parent.getParent().setRight(node);
      }

      parent.setLeft(node.getRight());
      node.getRight().setParent(parent);
      node.setRight(parent);
      parent.setParent(node);
    }

    return node;
  }
Exemple #11
0
  private void afterInsert(Node node) {

    Node parent = node.getParent();
    Node uncle = node.getUncle();
    Node grandParent = node.getGrandParent();

    if (node != root) {

      if (parent.isRed()) {

        if (parent.isRed() && uncle.isRed()) {
          grandParent.setColor(RED);
          parent.setColor(BLACK);
          uncle.setColor(BLACK);
          afterInsert(grandParent);

        } else if (grandParent != null) {

          if (parent.isLeft()) {
            if (node.isRight()) parent = rotateLeft(node);

            parent = rotateRight(parent);
            parent.setColor(BLACK);
            parent.getRight().setColor(RED);
          } else {
            if (node.isLeft()) parent = rotateRight(node);

            parent = rotateLeft(parent);
            parent.setColor(BLACK);
            parent.getLeft().setColor(RED);
          }
        }
      }
    }

    root.setColor(BLACK);
  }
Exemple #12
0
  public static void main(String args[]) {
    try {

      /*Please copy the test content into the file and unmark the line below to test the corresponding algorithm*/

      FileInputStream fstream = new FileInputStream("src/input_file/correlator.txt");

      /*----------------------------------------------------------------------------------*/

      // Get the object of DataInputStream
      DataInputStream in = new DataInputStream(fstream);
      BufferedReader br = new BufferedReader(new InputStreamReader(in));
      String strLine;
      int vertexNum = 0;
      int i = 0;
      int numOfRows = 0;
      String fileName = "";
      String[] anArray = new String[100];
      String[] originalFile = new String[100];
      String[] arrayString;
      int[] vertexWeight = new int[500];
      String vertexWeightString;
      int lineOfG = 0;
      int lineOfE = 0;
      int flag = 1;

      while ((strLine = br.readLine()) != null) {
        // Print the content on the console
        String original = strLine;
        String noSpaceString = strLine.replaceAll(" ", "");
        noSpaceString = noSpaceString.replaceAll("\t", "");

        if (noSpaceString.indexOf("#") != -1) {
          int indexOfSharp = noSpaceString.indexOf("#");
          noSpaceString = noSpaceString.substring(0, indexOfSharp);
        }

        if (noSpaceString.indexOf(".name") != -1) {
          int fileNameLength = noSpaceString.length();
          fileName = noSpaceString.substring(5, fileNameLength);
        } else if (noSpaceString.indexOf(".n") != -1) {
          String vertexNumString = noSpaceString.substring(2);
          vertexNum = string2int(vertexNumString);
        } else if (noSpaceString.indexOf(".d") != -1) {
          arrayString = new String[vertexNum];
          String tryString = original.substring(2);
          char[] tryCharArray = tryString.toCharArray();
          int indexLast;
          int t = 0;
          for (int c = 0; c < vertexNum; c++) {
            while (tryCharArray[1] == 32) {
              tryString = tryString.substring(1);
              tryCharArray = tryString.toCharArray();
            }
            if (c != vertexNum - 1) {
              indexLast = tryString.indexOf(32, 1);
              arrayString[t] = tryString.substring(1, indexLast);
              t++;
              tryString = tryString.substring(indexLast);
              tryCharArray = tryString.toCharArray();
              indexLast = 0;
            } else {
              if (tryString.indexOf(32, 1) == -1) {
                indexLast = tryString.length();
                arrayString[t] = tryString.substring(1, indexLast);
              } else {
                indexLast = tryString.indexOf(32, 1);
                arrayString[t] = tryString.substring(1, indexLast);
              }
            }
          }

          for (int j = 0; j < vertexNum; j++) {
            vertexWeight[j] = string2int(arrayString[j]);
          }
        }

        if (noSpaceString.indexOf(".g") != -1) {
          lineOfG = numOfRows;
        }

        if (noSpaceString.indexOf(".g") != -1 || flag == 0) {

          anArray[i] = original;
          flag = 0;
        } else {
          anArray[i] = noSpaceString;
        }

        if (noSpaceString.indexOf(".e") != -1) {
          lineOfE = numOfRows;
        }
        originalFile[i] = original;
        i++;
        numOfRows++;
      }

      int numOfEdges = lineOfE - lineOfG - 1;

      if (numOfEdges == 0) {
        /*----------------------output files with NO edges-----------------------------------*/

        /*--------file #1: W and D matrices------------*/
        Writer output_1 = null;
        String fileNameWD = fileName + "-WD.txt";
        File file_1 = new File(fileNameWD);
        output_1 = new BufferedWriter(new FileWriter(file_1));
        String nextLine = "\r\n";

        output_1.write(" W matrix: ");
        output_1.write(nextLine);
        output_1.write("W ");
        for (int z = 0; z < vertexNum + 1; z++) {
          output_1.write("v" + z + " ");
        }
        output_1.write(nextLine);
        for (int w = 0; w <= vertexNum; w++) {
          String oneLine = " ";
          for (int n = 0; n <= vertexNum; n++) {
            if (n == 0) {
              oneLine = oneLine + "0" + "  ";
            } else {
              oneLine = oneLine + "x" + "  ";
            }
          }
          output_1.write("v" + w + oneLine);
          output_1.write(nextLine);
        }

        output_1.write(" D matrix: ");
        output_1.write(nextLine);
        output_1.write("D ");
        for (int z = 0; z < vertexNum + 1; z++) {
          output_1.write("v" + z + " ");
        }
        output_1.write(nextLine);
        for (int w = 0; w <= vertexNum; w++) {
          String oneLine = " ";
          for (int n = 0; n <= vertexNum; n++) {
            if (w == n && w == 0) {
              oneLine = " 0" + " ";
            } else if (w == n && w != 0) {
              oneLine = oneLine + vertexWeight[n - 1] + "  ";
            } else {
              oneLine = oneLine + "x" + "  ";
            }
          }
          output_1.write("v" + w + oneLine);
          output_1.write(nextLine);
        }

        output_1.close();
        System.out.println("\n" + "Your output file #1 - WD matrices has been written");

        /*--------------------file #2: opt_phi constraints-------------------*/
        Writer output_2 = null;
        String fileNameConstraints = fileName + "-constraints.txt";
        File file_2 = new File(fileNameConstraints);
        output_2 = new BufferedWriter(new FileWriter(file_2));

        output_2.write("The following are constraints 9.4: ");
        output_2.write(nextLine);
        output_2.write(
            "r_i - r_j <=  "
                + Integer.toString(Integer.MIN_VALUE)
                + "    i, j <- [0 "
                + Integer.toString(vertexNum + 1)
                + "]");
        output_2.write(nextLine);
        output_2.write("The following are constraints 9.5: ");
        output_2.write(nextLine);
        output_2.write(
            "r_i - r_j <=  "
                + Integer.toString(Integer.MIN_VALUE)
                + "    i, j <- [0 "
                + Integer.toString(vertexNum + 1)
                + "]");

        output_2.close();
        System.out.println("\n" + "Your output file #2 - constraints has been written");

        /*--------------------file #3: constraint graph-------------------*/
        Writer output_3 = null;
        String fileNameCG = fileName + "-CG.txt";
        File file_3 = new File(fileNameCG);
        output_3 = new BufferedWriter(new FileWriter(file_3));
        int file_3NumOfLines = 12;

        for (int w = 0; w <= lineOfG; w++) {
          output_3.write(originalFile[w]);
          output_3.write(nextLine);
        }
        output_3.write(
            "r_i - r_j <=  "
                + Integer.toString(Integer.MIN_VALUE)
                + "    i, j <- [0 "
                + Integer.toString(vertexNum + 1)
                + "]");
        output_3.write(nextLine);
        output_3.write(
            "r_i - r_j <=  "
                + Integer.toString(Integer.MIN_VALUE)
                + "    i, j <- [0 "
                + Integer.toString(vertexNum + 1)
                + "]");
        output_3.write(nextLine);
        output_3.write(".e");
        output_3.close();
        System.out.println("\n" + "Your output file #3 - constraint graph has been written");

        /*--------------------file #4: intermidiate BF-------------------*/
        Writer output_4 = null;
        String fileNameBF = fileName + "-BF.txt";
        File file_4 = new File(fileNameBF);
        output_4 = new BufferedWriter(new FileWriter(file_4));
        output_4.write("Following shows the path weight vectors: ");
        output_4.write(nextLine);
        for (int t = 0; t < 2; t++) {
          output_4.write("s^" + t + ": ");
          for (int r = 0; r < vertexNum + 1; r++) {
            if (r == 0) {
              output_4.write("0" + " ");
            } else {
              output_4.write(Integer.toString(Integer.MIN_VALUE) + " ");
            }
          }
          output_4.write(nextLine);
        }
        output_4.write(nextLine);
        output_4.write("In the 2th iteration, the algorithm reaches the stable value.");

        output_4.close();
        System.out.println("\n" + "Your output file #4 - BF has been written");

        /*--------------------file #5: correlator-retiming-summary.txt-------------------*/
        Writer output_5 = null;
        String fileNameSM = "correlator-retiming-summary.txt";
        File file_5 = new File(fileNameSM);
        output_5 = new BufferedWriter(new FileWriter(file_5));
        output_5.write("The optimal retiming vector is: ");
        for (int r = 0; r < vertexNum + 1; r++) {
          if (r == 0) {
            output_5.write("0" + " ");
          } else {
            output_5.write(Integer.toString(Integer.MIN_VALUE) + " ");
          }
        }
        output_5.write(nextLine);
        output_5.write("The optimal clock cycle time is: N/A");
        output_5.write(nextLine);
        output_5.write("The initial(legal) clock cycle time is: N/A");
        output_5.close();
        System.out.println("\n" + "Your output file #5 - SM has been written");

        /*--------------------file #6: correlator-out.txt-------------------*/
        Writer output_6 = null;
        String fileNameOUT = "correlator-out.txt";
        File file_6 = new File(fileNameOUT);
        output_6 = new BufferedWriter(new FileWriter(file_6));

        for (int w = 0; w <= lineOfG; w++) {
          output_6.write(originalFile[w]);
          output_6.write(nextLine);
        }
        output_6.write(".e");

        output_6.close();
        System.out.println("\n" + "Your output file #6 - OUT has been written");

      } else {
        /*-------initial nodes-----------*/
        Node node = new Node();
        node.delay = 1;

        Node nodes[] = new Node[vertexNum + 1];
        nodes[0] = new Node(0, 0);
        for (int n = 1; n < vertexNum + 1; n++) {
          nodes[n] = new Node(n, vertexWeight[n - 1]);
        }

        /*----------initial edges-----------*/

        System.out.println("Number of vertices:" + vertexNum);
        System.out.println("Number of edges: " + numOfEdges);

        Edge[] edges = new Edge[numOfEdges];
        for (int e = 0; e < numOfEdges; e++) {
          char[] edgeLine = anArray[lineOfG + 1 + e].toCharArray();
          int firstSpace = anArray[lineOfG + 1 + e].indexOf(' ');
          int secondSpace = anArray[lineOfG + 1 + e].indexOf(' ', firstSpace + 1);
          int mult = 1;
          int indexFrom = 0;
          int indexTo = 0;
          for (int n = firstSpace - 1; n >= 0; n--) {
            indexFrom = (edgeLine[n] - 48) * mult + indexFrom;
            mult = mult * 10;
          }
          mult = 1;
          for (int n = secondSpace - 1; n > firstSpace; n--) {
            indexTo = (edgeLine[n] - 48) * mult + indexTo;
            mult = mult * 10;
          }
          int edgeWeight = edgeLine[secondSpace + 1] - 48;
          edges[e] = new Edge(nodes[indexFrom], nodes[indexTo], edgeWeight);
        }

        /*-----------test read file-----------------
        for (int p = 0; p < numOfEdges; p++){
         System.out.println("Edge Weight Attr 1" + p + ": " + edges[p].weight[0]);
         System.out.println("Edge Weight Attr 2" + p + ": " + edges[p].weight[1]);
        }
        */

        int[][] p;
        int[][] q;
        LinkedList<String> wholeConstraints = new LinkedList<String>();
        LinkedList<String> reducedConstraints = new LinkedList<String>();
        int possiblePhi;
        int phi_opt;

        FloydWarshall FW = new FloydWarshall(nodes, edges);
        p = FW.W;
        q = FW.D;

        int[] unsortedDEle = new int[q.length * q.length];

        System.out.println("\n W matrix: ");
        for (int m = 0; m < nodes.length; m++) {
          for (int n = 0; n < nodes.length; n++) {
            System.out.print(p[m][n] + " ");
          }
          System.out.print('\n');
        }

        System.out.println("\n D matrix: ");

        for (int m = 0; m < nodes.length; m++) {
          for (int n = 0; n < nodes.length; n++) {
            System.out.print(q[m][n] + " ");
          }
          System.out.print('\n');
        }

        /*----------insertion sort-----------*/
        int pointer = 0;
        for (int n = 0; n < nodes.length; n++) {
          for (int m = 0; m < nodes.length; m++) {
            unsortedDEle[pointer] = q[n][m];
            pointer++;
          }
        }

        for (int t = 1; t < (vertexNum + 1) * (1 + vertexNum); t++) {
          int key = unsortedDEle[t];
          int s = t - 1;
          while (s >= 0 && unsortedDEle[s] > key) {
            unsortedDEle[s + 1] = unsortedDEle[s];
            s = s - 1;
          }
          unsortedDEle[s + 1] = key;
        }

        System.out.println(" \n" + "unsorted D element:  ");
        for (int m = 0; m < (vertexNum + 1) * (1 + vertexNum); m++) {
          System.out.print(unsortedDEle[m] + " ");
        }

        int adder = 1;
        int numOfTry = 1;
        for (int h = 1; h < (vertexNum + 1) * (1 + vertexNum); h++) {
          if (unsortedDEle[h] != unsortedDEle[adder - 1]) {
            unsortedDEle[adder] = unsortedDEle[h];
            adder++;
            numOfTry++;
          }
        }
        int[] testDEle = new int[numOfTry];
        for (int x = 0; x < numOfTry; x++) {
          testDEle[x] = unsortedDEle[x];
        }

        System.out.println(" \n" + "sorted D element:  ");
        for (int m = 0; m < numOfTry; m++) {
          System.out.print(testDEle[m] + " ");
        }

        int initialPhi = 0;
        for (int ii = 0; ii < (vertexNum + 1); ii++) {
          for (int jj = 0; jj < (vertexNum + 1); jj++) {
            if (p[ii][jj] == 0 && q[ii][jj] > initialPhi) {
              initialPhi = q[ii][jj];
            }
          }
        }
        System.out.println(" \n" + "initial Phi:  " + initialPhi + "\n");

        int highPointer = testDEle.length - 1;
        int lowPointer = 0;
        int currentPhi = testDEle[0];
        int firstLegalPhiFlag = 0;
        int firstLegalPhi = Integer.MAX_VALUE;
        int lastLegalPhi = Integer.MAX_VALUE;

        while (highPointer >= lowPointer) {

          int currentPointer = (int) (highPointer - lowPointer) / 2 + lowPointer;
          currentPhi = testDEle[currentPointer];
          reducedConstraints = FW.reduceConstraint(p, q, nodes, edges, currentPhi);
          wholeConstraints = FW.basicConstraint(p, q, nodes, edges, currentPhi);
          int[][] sortedConstraints = FW.radix(FW.constraintGraph, nodes);
          if (FW.bellmanFord(nodes, FW.constraintGraph, sortedConstraints)) {
            highPointer = currentPointer - 1;
            if (firstLegalPhiFlag == 0) {
              firstLegalPhiFlag = 1;
              firstLegalPhi = currentPhi;
            }
            if (firstLegalPhiFlag == 1) {
              lastLegalPhi = currentPhi;
            }
          } else {
            lowPointer = currentPointer + 1;
          }
        }
        reducedConstraints = FW.reduceConstraint(p, q, nodes, edges, currentPhi);
        wholeConstraints = FW.basicConstraint(p, q, nodes, edges, currentPhi);
        // FW.bellmanFord(nodes, FW.constraintGraph,sortedConstraints);
        int[][] sortedConstraints = FW.radix(FW.constraintGraph, nodes);
        System.out.println("\n\n" + "whole contraints: " + "\n" + wholeConstraints);
        System.out.println("\n" + "reduced contraints: " + "\n" + reducedConstraints);
        System.out.println("\n" + "reduced contraints size: " + reducedConstraints.size());
        System.out.println("\n" + "first legal phi: " + firstLegalPhi);
        System.out.println("\n" + "last legal phi: " + lastLegalPhi);

        System.out.println("\n\n This is iteration vectors:");
        if (FW.bellmanFord(nodes, FW.constraintGraph, sortedConstraints)) {
          for (int t = 0; t <= FW.numOfBFIteration; t++) {
            System.out.print("s^" + t + ": ");
            for (int r = 0; r < vertexNum + 1; r++) {
              System.out.print(FW.iterationVector.get(t)[r] + " ");
            }
            System.out.print("\n");
          }
        }

        System.out.print("\n\n number of iterations: " + FW.numOfBFIteration + "\n");

        /*----------------------output files-----------------------------------*/

        /*--------file #1: W and D matrices------------*/
        Writer output_1 = null;
        String fileNameWD = fileName + "-WD.txt";
        File file_1 = new File(fileNameWD);
        output_1 = new BufferedWriter(new FileWriter(file_1));
        String nextLine = "\r\n";
        for (int w = 0; w <= vertexNum + 1; w++) {
          if (w == 0) {
            output_1.write(" W matrix: ");
            output_1.write(nextLine);
            output_1.write("W ");
            for (int z = 0; z < vertexNum + 1; z++) {
              output_1.write("v" + z + " ");
            }
            output_1.write(nextLine);
          } else {
            String oneLine = " ";
            for (int n = 0; n <= vertexNum; n++) {
              oneLine = oneLine + Integer.toString(p[w - 1][n]) + " ";
            }
            int wcol = w - 1;
            output_1.write("v" + wcol + oneLine);
            output_1.write(nextLine);
          }
        }

        output_1.write(nextLine);

        for (int w = 0; w <= vertexNum + 1; w++) {
          if (w == 0) {
            output_1.write(" D matrix: ");
            output_1.write(nextLine);
            output_1.write("D ");
            for (int z = 0; z < vertexNum + 1; z++) {
              output_1.write("v" + z + " ");
            }
            output_1.write(nextLine);
          } else {
            String oneLine = " ";
            for (int n = 0; n <= vertexNum; n++) {
              oneLine = oneLine + Integer.toString(q[w - 1][n]) + " ";
            }
            int dcol = w - 1;
            output_1.write("v" + dcol + oneLine);
            output_1.write(nextLine);
          }
        }

        output_1.close();
        System.out.println("\n" + "Your output file #1 - WD matrices has been written");

        /*--------------------file #2: opt_phi constraints-------------------*/
        Writer output_2 = null;
        String fileNameConstraints = fileName + "-constraints.txt";
        File file_2 = new File(fileNameConstraints);
        output_2 = new BufferedWriter(new FileWriter(file_2));
        int lengthOfFile2 = reducedConstraints.size() + 1;

        for (int w = 0; w < lengthOfFile2; w++) {
          if (w == 0) {
            output_2.write(" This is final constraints file: ");
            output_2.write(nextLine);
          } else {
            output_2.write(reducedConstraints.get(w - 1));
            output_2.write(nextLine);
          }
        }

        output_2.close();
        System.out.println("\n" + "Your output file #2 - constraints has been written");

        /*--------------------file #3: constraint graph-------------------*/
        Writer output_3 = null;
        String fileNameCG = fileName + "-CG.txt";
        File file_3 = new File(fileNameCG);
        output_3 = new BufferedWriter(new FileWriter(file_3));
        int numOfConstraints = sortedConstraints.length;
        int file_3NumOfLines = numOfConstraints + 10;
        int base = numOfConstraints;

        for (int w = 0; w < file_3NumOfLines; w++) {
          if (w <= lineOfG) {
            output_3.write(originalFile[w]);
            output_3.write(nextLine);
          } else if (base > 0) {
            for (int y = 0; y < 3; y++) {
              output_3.write(Integer.toString(sortedConstraints[numOfConstraints - base][y]) + " ");
            }
            base--;
            output_3.write(nextLine);
          } else if (w == file_3NumOfLines - 1) {
            output_3.write(".e");
            output_3.write(nextLine);
          }
        }

        output_3.close();
        System.out.println("\n" + "Your output file #3 - constraint graph has been written");

        /*--------------------file #4: intermidiate BF-------------------*/
        Writer output_4 = null;
        String fileNameBF = fileName + "-BF.txt";
        File file_4 = new File(fileNameBF);
        output_4 = new BufferedWriter(new FileWriter(file_4));
        output_4.write("Following shows the path weight vectors: ");
        output_4.write(nextLine);
        for (int t = 0; t <= FW.numOfBFIteration; t++) {
          output_4.write("s^" + t + ": ");
          for (int r = 0; r < vertexNum + 1; r++) {
            output_4.write(FW.iterationVector.get(t)[r] + " ");
          }
          output_4.write(nextLine);
        }
        output_4.write(nextLine);
        output_4.write(
            "In the "
                + FW.numOfBFIteration
                + "th iteration, the algorithm reaches the stable value.");

        output_4.close();
        System.out.println("\n" + "Your output file #4 - BF has been written");

        /*--------------------file #5: correlator-retiming-summary.txt-------------------*/
        Writer output_5 = null;
        String fileNameSM = fileName + "-summary.txt";
        File file_5 = new File(fileNameSM);
        output_5 = new BufferedWriter(new FileWriter(file_5));
        output_5.write("The optimal retiming vector is: ");
        for (int r = 0; r < vertexNum; r++) {
          int m = FW.iterationVector.getLast()[r];
          output_5.write(Integer.toString(FW.iterationVector.getLast()[r]) + " ");
        }
        output_5.write(nextLine);
        output_5.write("The optimal clock cycle time is: ");
        if (lastLegalPhi != Integer.MAX_VALUE) {
          output_5.write(Integer.toString(lastLegalPhi));
        } else {
          output_5.write("N/A");
        }
        output_5.write(nextLine);
        output_5.write("The initial(legal) clock cycle time is: ");
        if (firstLegalPhi != Integer.MAX_VALUE) {
          output_5.write(Integer.toString(initialPhi));
        } else {
          output_5.write("N/A");
        }
        output_5.close();
        System.out.println("\n" + "Your output file #5 - SM has been written");

        /*--------------------file #6: correlator-out.txt-------------------*/
        Writer output_6 = null;
        String fileNameOUT = fileName + "-out.txt";
        File file_6 = new File(fileNameOUT);
        output_6 = new BufferedWriter(new FileWriter(file_6));
        output_6.write(".name correlator-out");
        output_6.write(nextLine);
        output_6.write(".n " + (nodes.length - 1));
        output_6.write(nextLine);
        output_6.write(".d ");
        for (int x = 1; x < nodes.length; x++) {
          output_6.write(Integer.toString(nodes[x].delay) + " ");
        }
        output_6.write(nextLine);
        output_6.write(".r ");
        for (int y = 1; y < nodes.length; y++) {
          output_6.write(Integer.toString(FW.iterationVector.getLast()[y]) + " ");
        }
        output_6.write(nextLine);
        output_6.write(".g");
        output_6.write(nextLine);
        for (int m = 0; m < nodes.length; m++) {
          for (int n = 0; n < nodes.length; n++) {
            for (int s = 0; s < edges.length; s++) {
              if (edges[s].from.index == m && edges[s].to.index == n) {
                output_6.write(Integer.toString(m) + " ");
                output_6.write(Integer.toString(n) + " ");
                output_6.write(
                    Integer.toString(
                        edges[s].weight[0]
                            + FW.iterationVector.getLast()[n]
                            - FW.iterationVector.getLast()[m]));
                output_6.write(nextLine);
              }
            }
          }
        }
        output_6.write(".e");

        output_6.close();
        System.out.println("\n" + "Your output file #6 - OUT has been written");
      }
    } catch (Exception e) { // Catch exception if any
      System.err.println("Error: " + e.getMessage());
    }
  }