Percolation

Percolation.java
==================
public class Percolation {
 private enum State {
  BLOCKD, OPEN, FULL
 }

 private State[][] site;
 private int N;
 private WeightedQuickUnionUF unionFindHelper;

 public Percolation(int N) // create N-by-N grid, with all sites blocked
 {
  if (N <= 0)
     throw new IllegalArgumentException();
  this.N = N;
  unionFindHelper = new WeightedQuickUnionUF(N * N + 2);
  site = new State[N][N];
  for (int i = 0; i < N; i++) {
   for (int j = 0; j < N; j++) {
    site[i][j] = State.BLOCKD;
   }
  }

 }

 public void open(int i, int j) // open site (row i, column j) if it is not
 // open already
 {
  if ((i < 1) || (i > N))
   throw new IndexOutOfBoundsException("row index i out of bounds");

  if ((j < 1) || (j > N))
   throw new IndexOutOfBoundsException("row index j out of bounds");

  if (isOpen(i, j))
   return;
  else
   site[i - 1][j - 1] = State.OPEN;

  if (i == 1) {
   unionFindHelper.union(0, twoDimensionToOneDimension(i, j));
  }

  if (i == N) {
   unionFindHelper.union(twoDimensionToOneDimension(i, j), N * N + 1);
  }

  if (isValidSite(i - 1, j) && (isOpen(i - 1, j) || isFull(i - 1, j))) {
   unionFindHelper.union(twoDimensionToOneDimension(i, j),
     twoDimensionToOneDimension(i - 1, j));
 
   if(unionFindHelper.connected(0, twoDimensionToOneDimension(i-1, j)))
  site[i-2][j-1] = State.FULL;
  }

  if (isValidSite(i, j - 1) && (isOpen(i, j - 1) || isFull(i, j - 1))) {
   unionFindHelper.union(twoDimensionToOneDimension(i, j),
     twoDimensionToOneDimension(i, j - 1));
 
   if(unionFindHelper.connected(0, twoDimensionToOneDimension(i, j-1)))
  site[i-1][j-2] = State.FULL;
  }

  if (isValidSite(i, j + 1) && (isOpen(i, j + 1) || isFull(i, j + 1))) {
   unionFindHelper.union(twoDimensionToOneDimension(i, j),
     twoDimensionToOneDimension(i, j + 1));

   if(unionFindHelper.connected(0, twoDimensionToOneDimension(i, j + 1)))
  site[i-1][j] = State.FULL;
  }

  if (isValidSite(i + 1, j) && (isOpen(i + 1, j) || isFull(i + 1, j))) {
   unionFindHelper.union(twoDimensionToOneDimension(i, j),
     twoDimensionToOneDimension(i + 1, j));
 
   if(unionFindHelper.connected(0, twoDimensionToOneDimension(i+1, j)))
  site[i][j-1] = State.FULL;
  }

  if (unionFindHelper.connected(0, twoDimensionToOneDimension(i, j))) {
   site[i - 1][j - 1] = State.FULL;
  }

 }

 private int twoDimensionToOneDimension(int i, int j) {
  // TODO Auto-generated method stub
  return (i - 1) * N + j;
 }

 private boolean isValidSite(int i, int j) {
     return !((i < 1) || (i > N) || (j < 1) || (j > N));
 }

 public boolean isOpen(int i, int j) // is site (row i, column j) open?
 {
  if (!isValidSite(i, j))
   throw new IndexOutOfBoundsException();

  return (site[i - 1][j - 1] == State.OPEN) || (site[i - 1][j - 1] == State.FULL);
 }

 public boolean isFull(int i, int j) // is site (row i, column j) full?
 {
  if (!isValidSite(i, j))
   throw new IndexOutOfBoundsException();
  return (site[i - 1][j - 1] == State.FULL);
 }

 public boolean percolates() // does the system percolate?
 {
  return unionFindHelper.connected(0, N * N + 1);

 }

 public static void main(String[] args) // test client (optional)
 {int N=2;
  Percolation p = new Percolation(N);
  p.open(1, 1);
  p.open(2, 2);
  p.open(2, 1);
  System.out.println(p.isFull(1, 1));
 
  for(int i=0;i<N;i++)
  {  for(int j=0;j<N;j++)
  {
 System.out.print(p.site[i][j]+ " ");
  }
  System.out.println();
  }
 }
}

PercolationStats.java

==================

public class PercolationStats {

 private int T;

 private double[] percolationThresholdArray;

 public PercolationStats(int N, int T) // perform T independent experiments

 // on an N-by-N grid

 {

  this.T = T;

  if (N <= 0 || T <= 0) {

   throw new IllegalArgumentException();

  }

  percolationThresholdArray = new double[T];

  for (int t = 0; t < T; t++) {

   Percolation percolation = new Percolation(N);

   int row;

   int col;

   int numberOfSiteOpend = 0;

   while (!percolation.percolates()) {

    row = StdRandom.uniform(N) + 1;

    col = StdRandom.uniform(N) + 1;

    if (!percolation.isOpen(row, col)) {

     percolation.open(row, col);

     numberOfSiteOpend++;

    }

   }

   percolationThresholdArray[t] = (double) numberOfSiteOpend

     / (double) (N * N);

  }

 }

 public double mean() // sample mean of percolation threshold

 {

  double mean = 0;

  for (int t = 0; t < T; t++) {

   mean += percolationThresholdArray[t];

  }

  mean = mean / T;

  return mean;

 }

 public double stddev() // sample standard deviation of percolation threshold

 {

  double stdDev = 0;

  double mean = this.mean();

  for (int t = 0; t < T; t++) {

   stdDev += (percolationThresholdArray[t] - mean)

     * (percolationThresholdArray[t] - mean);

  }

  stdDev = stdDev / (T - 1);

  stdDev = Math.pow(stdDev, 0.5);

  return stdDev;

 }

 public double confidenceLo() // low endpoint of 95% confidence interval

 {

  double mu = mean();

  double sigma = stddev();

  double confidence = mu - (1.96 * sigma / Math.pow(T, 0.5));

  return confidence;

 }

 public double confidenceHi() // high endpoint of 95% confidence interval

 {

  double mu = mean();

  double sigma = stddev();

  double confidence = mu + (1.96 * sigma / Math.pow(T, 0.5));

  return confidence;

 }

 public static void main(String[] args) {

  if (args.length == 2) {

   try {

    int N = Integer.parseInt(args[0]);

    int T = Integer.parseInt(args[1]);

    PercolationStats ps = new PercolationStats(N, T);

    System.out.println("mean                    = " + ps.mean());

    System.out.println("stddev                  = " + ps.stddev());

    System.out.println("95% confidence interval = "

      + ps.confidenceLo() + ", " + ps.confidenceHi());

    System.out.println("\n");

   } catch (NumberFormatException e) {

    System.err.println("Argument" + args[0]

      + " must be an integer.");

   }

  }

 }

}