public void kNNClassify(Instances test) {
    Instance testSample = null;
    DistanceAlgorithm d = new EucledianDistance();
    Map<Double, List<Instance>> hp;
    int[] count = new int[2];
    for (int i = 0; i < test.getDataSetSize(); i++) {
      count[0] = 0;
      count[1] = 0;
      distanceQueue = new ArrayList<DistanceInstanceMap>();
      testSample = test.getInstance(i);

      for (int j = 0; j < data.getDataSetSize(); j++) {
        Double distance = new Double(d.distance(testSample, data.getInstance(j)));
        distanceQueue.add(new DistanceInstanceMap(distance, data.getInstance(j)));
      }
      Collections.sort(distanceQueue);
      for (int j = 0; j < 1; j++) {
        DistanceInstanceMap dimap = distanceQueue.get(j);
        Instance inst = dimap.getInstance();
        if (inst.getClassValue() == 0) {
          count[0]++;
        } else {
          count[1]++;
        }
      }
      if (count[0] > count[1]) {
        testSample.setPredictedClass(0);
      } else {
        testSample.setPredictedClass(1);
      }
    }
  }
  public static void testCV(DataFileReader ip) {
    try {
      Instances dataSet = ip.loadDataFromFile();
      MinMaxNormalizer minMaxNorm = new MinMaxNormalizer();
      ConfusionMatrix averageConfusionMatrix = new ConfusionMatrix();
      int crossValidation = 10;
      for (int i = 1; i <= crossValidation; i++) {
        Instances train = dataSet.getTrainingForCrossValidation(crossValidation, i);
        Instances test = dataSet.getTestForCrossValidation();
        test = test.normalize(minMaxNorm);
        train = train.normalize(minMaxNorm);
        KNearestNeighbor kNNClassifier = new KNearestNeighbor(train);
        kNNClassifier.kNNClassify(test);

        ConfusionMatrix cm = new ConfusionMatrix();
        for (int j = 0; j < test.getDataSetSize(); j++) {
          Instance t = test.getInstance(j);
          if (t.isCorrectClassified()) {
            // true
            if (t.getClassValue() == 1) {
              // positive
              cm.incrementTruePositive();
            } else {
              // negative
              cm.incrementTrueNegative();
            }
          } else {
            // false
            if (t.getClassValue() == 1) {
              // positive
              cm.incrementFalsePositive();
            } else {
              // negative
              cm.incrementFalseNegative();
            }
          }
        }
        averageConfusionMatrix.addToTruePositive(cm.getTruePositive());
        averageConfusionMatrix.addToFalsePositive(cm.getFalsePositive());
        averageConfusionMatrix.addToTrueNegative(cm.getTrueNegative());
        averageConfusionMatrix.addToFalseNegative(cm.getFalseNegative());
      }
      System.out.format("\t Average Accuracy %f \n", averageConfusionMatrix.getAccuracy());
      System.out.format("\t Average Precision %f \n", averageConfusionMatrix.getPrecision());
      System.out.format("\t Average Recall %f \n", averageConfusionMatrix.getRecall());
      System.out.format("\t Average F-Measure %f \n", averageConfusionMatrix.getFmeasure());

    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static void testD3(DataFileReader ip) {
    String stemFileName = "dataset3";
    String delimiter = "\t";
    try {
      Instances train = ip.loadDataFromFile();
      MinMaxNormalizer minMaxNorm = new MinMaxNormalizer();
      Instances test =
          new TestFileReader(stemFileName, delimiter).loadDataFromFile(train.getHeader());
      test = test.normalize(minMaxNorm);
      train = train.normalize(minMaxNorm);
      KNearestNeighbor kNNClassifier = new KNearestNeighbor(train);
      kNNClassifier.kNNClassify(test);

      ConfusionMatrix cm = new ConfusionMatrix();
      for (int j = 0; j < test.getDataSetSize(); j++) {
        Instance t = test.getInstance(j);
        if (t.isCorrectClassified()) {
          // true
          if (t.getClassValue() == 1) {
            // positive
            cm.incrementTruePositive();
          } else {
            // negative
            cm.incrementTrueNegative();
          }
        } else {
          // false
          if (t.getClassValue() == 1) {
            // positive
            cm.incrementFalsePositive();
          } else {
            // negative
            cm.incrementFalseNegative();
          }
        }
      }
      System.out.format("\t Accuracy %f \n", cm.getAccuracy());
      System.out.format("\t Precision %f \n", cm.getPrecision());
      System.out.format("\t Recall %f \n", cm.getRecall());
      System.out.format("\t F-Measure %f \n", cm.getFmeasure());
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }