code: ///////////////////////////////////////////////////////////////////////////////
  // For information as to what this class does, see the Javadoc, below.       //
  // Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,       //
  // 2007, 2008, 2009, 2010, 2014, 2015 by Peter Spirtes, Richard Scheines, Joseph   //
  // Ramsey, and Clark Glymour.                                                //
  //                                                                           //
  // This program is free software; you can redistribute it and/or modify      //
  // it under the terms of the GNU General Public License as published by      //
  // the Free Software Foundation; either version 2 of the License, or         //
  // (at your option) any later version.                                       //
  //                                                                           //
  // This program is distributed in the hope that it will be useful,           //
  // but WITHOUT ANY WARRANTY; without even the implied warranty of            //
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             //
  // GNU General Public License for more details.                              //
  //                                                                           //
  // You should have received a copy of the GNU General Public License         //
  // along with this program; if not, write to the Free Software               //
  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA //
  ///////////////////////////////////////////////////////////////////////////////
  
  package edu.pitt.dbmi.algo.bayesian.constraint.inference;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.regex.Pattern;
  
  /**
   *
   * Feb 22, 2014 3:26:17 PM
   *
   * @author Kevin V. Bui (kvb2@pitt.edu)
   */
  public class BayesianConstraintInference {
  
      private static final String CAS_FLAG = "--cas";
  
      private static final int NUM_REQ_ARGS = 2;
  
      private static final String USAGE = "java -jar bci.jar --cas <cas-file>";
  
      private static File casFile;
  
      /**
       * @param args the command line arguments
       */
      public static void main(String[] args) {
          if (args == null || args.length != NUM_REQ_ARGS) {
              System.err.println(USAGE);
              System.exit(127);
          }
  
          for (int i = 0; i < args.length; i++) {
              String flag = args[i];
              if (flag.equals(CAS_FLAG)) {
                  casFile = new File(args[++i]);
                  checkFile(casFile, false);
              } else {
                  System.out.printf("Unknown switch %s.\n", flag);
                  System.exit(-1);
              }
          }
  
          try {
              int[][] dataset = readInDataset(casFile);
              int[] nodeDimension = readInNodeDimension(casFile);
              BCInference bci = new BCInference(dataset, nodeDimension);
  
              BCInference.OP constraint = BCInference.OP.dependent;
              int x = 3;
              int y = 5;
              int[] z = {0};  // empty set
              double pc = bci.probConstraint(constraint, x, y, z);  // returns P(node3 dependent node5 given {} | data)
              System.out.printf("Probability constraint: %7.5f\n", pc);  // if fn = 1 then 0.76510; if fn = 2 then 0.91311
  
              constraint = BCInference.OP.independent;
              x = 1;
              y = 4;
              z = new int[3];
              z[1] = 2;
              z[2] = 3;
              z[0] = 2;
              pc = bci.probConstraint(constraint, x, y, z);  // returns P(node1 independent node4 given {node2, node3} | data)
              System.out.printf("Probability constraint: %7.5f\n", pc);  // if fn = 1 then 0.34093; if fn = 2 then 0.35806
  
              constraint = BCInference.OP.independent;
              x = 1;
              y = 5;
              z = new int[2];
              z[1] = 3;
              z[0] = 1; //this is the length of the set represented by array Z.
              pc = bci.probConstraint(constraint, x, y, z);  // returns P(node1 independent node5 given {node3} | data)
              System.out.printf("Probability constraint: %7.5f\n", pc);  // if fn = 1 then 0.93535; if fn = 2 then 0.70853
  
  //            BCInference.OP constraint = BCInference.OP.independent;
  //            int x = 1;
  //            int y = 5;
  //            int[] z = new int[2];
  //            z[0] = 1;
  //            z[1] = 3;
  //            double pc = bci.probConstraint(constraint, x, y, z);  // returns P(node1 independent node5 given {node3} | data)
  //            System.out.printf("Probability constraint: %7.5f\n", pc);
  //
  //            constraint = BCInference.OP.dependent;
  //            x = 3;
  //            y = 5;
  //            z = new int[1];
  //            z[0] = 0;  // empty set
  //            pc = bci.probConstraint(constraint, x, y, z);  // returns P(node3 dependent node5 given {} | data)
  //            System.out.printf("Probability constraint: %7.5f\n", pc);
  //
  //            constraint = BCInference.OP.independent;
  //            x = 1;
  //            y = 4;
  //            z = new int[]{2, 2, 3};
  //            pc = bci.probConstraint(constraint, x, y, z);  // returns P(node1 independent node4 given {node2, node3} | data)
  //            System.out.printf("Probability constraint: %7.5f\n", pc);
          } catch (Exception exception) {
              exception.printStackTrace(System.err);
          }
      }
  
      private static int[] readInNodeDimension(File dataFile) throws IOException {
          int[] nodeDimension = null;
  
          Pattern spaceDelim = Pattern.compile("\\s+");
          BufferedReader reader = null;
          try {
              reader = new BufferedReader(new FileReader(dataFile));
  
              int numberOfNodes = Integer.parseInt(reader.readLine().trim());
              nodeDimension = new int[numberOfNodes + 2];
              String[] data = spaceDelim.split(reader.readLine().trim());
              int i = 0;
              for (String d : data) {
                  nodeDimension[++i] = Integer.parseInt(d);
              }
          } finally {
              if (reader != null) {
                  try {
                      reader.close();
                  } catch (IOException exception) {
                      exception.printStackTrace(System.err);
                  }
              }
          }
  
          return nodeDimension;
      }
  
      private static int[][] readInDataset(File dataFile) throws IOException {
          int[][] dataset = null;
  
          Pattern spaceDelim = Pattern.compile("\\s+");
          BufferedReader reader = null;
          try {
              reader = new BufferedReader(new FileReader(dataFile));
  
              int numberOfNodes = Integer.parseInt(reader.readLine().trim());
              reader.readLine();  // skip node dimension
              int numberOfCases = Integer.parseInt(reader.readLine().trim());
  
              dataset = new int[numberOfCases + 1][numberOfNodes + 2];
              for (int i = 1; i <= numberOfCases; i++) {
                  String[] data = spaceDelim.split(reader.readLine().trim());
                  int j = 0;
                  for (String d : data) {
                      dataset[i][++j] = Integer.parseInt(d);
                  }
              }
          } finally {
              if (reader != null) {
                  try {
                      reader.close();
                  } catch (IOException exception) {
                      exception.printStackTrace(System.err);
                  }
              }
          }
  
          return dataset;
      }
  
      private static void checkFile(File file, boolean checkDirectory) {
          if (file.exists()) {
              if (checkDirectory) {
                  if (file.isFile()) {
                      System.err.printf("%s is not a directory.", file.getName());
                      System.exit(-1);
                  }
              } else {
                  if (file.isDirectory()) {
                      System.err.printf("%s is not a file.", file.getName());
                      System.exit(-1);
                  }
              }
          } else {
              System.err.printf("%s does not exist.", file.getName());
              System.exit(-1);
          }
      }
  }
  
  
  