*/
	private List<IClassificationResult<Double>> generateFawcettDataset() {
	
		String[] names = new String[1]; names[0] = "class";
		NodeIndexing nodeIndexing = NodeIndexing.getNodeIndexing("FawcettDataset", names, names[0], null);
		
		Map<String,Integer> stateToIndex = new TreeMap<String,Integer>(); stateToIndex.put("p", 0); stateToIndex.put("n", 1); 
		String[] v;
		List<String[]> values;
		List<Double> times = new Vector<Double>(1); times.add( 0.0);
		double[] p;
		List<IClassificationResult<Double>> dataset = new LinkedList<IClassificationResult<Double>>();
		
		// trajectory 1
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		ITrajectory<Double> baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		IClassificationResult<Double> trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.9; p[stateToIndex.get("n")] = 0.1; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("1");
		dataset.add(trj);
		
		// trajectory 2
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.8; p[stateToIndex.get("n")] = 0.2; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("2");
		dataset.add(trj);
		
		// trajectory 3
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.7; p[stateToIndex.get("n")] = 0.3; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("3");
		dataset.add(trj);
		
		// trajectory 4
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.6; p[stateToIndex.get("n")] = 0.4; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("4");
		dataset.add(trj);
		
		// trajectory 5
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.55; p[stateToIndex.get("n")] = 0.45; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("5");
		dataset.add(trj);
		
		// trajectory 6
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.54; p[stateToIndex.get("n")] = 0.46; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("6");
		dataset.add(trj);
		
		// trajectory 7
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.53; p[stateToIndex.get("n")] = 0.47; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("7");
		dataset.add(trj);
		
		// trajectory 8
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.52; p[stateToIndex.get("n")] = 0.48; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("8");
		dataset.add(trj);
		
		// trajectory 9
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.51; p[stateToIndex.get("n")] = 0.49; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("9");
		dataset.add(trj);
		
		// trajectory 10
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.505; p[stateToIndex.get("n")] = 0.495; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("p");				// predicted class
		trj.setName("10");
		dataset.add(trj);
		
		// trajectory 11
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.4; p[stateToIndex.get("n")] = 0.6; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("11");
		dataset.add(trj);
		
		// trajectory 12
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.39; p[stateToIndex.get("n")] = 0.61; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("12");
		dataset.add(trj);
		
		// trajectory 13
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.38; p[stateToIndex.get("n")] = 0.62; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("13");
		dataset.add(trj);
		
		// trajectory 14
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.37; p[stateToIndex.get("n")] = 0.63; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("14");
		dataset.add(trj);
		
		// trajectory 15
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.36; p[stateToIndex.get("n")] = 0.64; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("15");
		dataset.add(trj);
		
		// trajectory 16
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.35; p[stateToIndex.get("n")] = 0.65; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("16");
		dataset.add(trj);
		
		// trajectory 17
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.34; p[stateToIndex.get("n")] = 0.66; 
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("17");
		dataset.add(trj);
		
		// trajectory 18
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.33; p[stateToIndex.get("n")] = 0.67;  
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("18");
		dataset.add(trj);
		
		// trajectory 19
		v = new String[1];
		v[0] = "p";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.3; p[stateToIndex.get("n")] = 0.7;   
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("19");
		dataset.add(trj);
		
		// trajectory 20
		v = new String[1];
		v[0] = "n";								// true class
		values = new Vector<String[]>(1); values.add(v);
		baseTrj = new CTTrajectory<Double>(nodeIndexing, times, values);
		trj = new ClassificationResults<Double>(baseTrj);
		p = new double[2]; p[stateToIndex.get("p")] = 0.1; p[stateToIndex.get("n")] = 0.9;  
		trj.setProbability(0, p, stateToIndex);
		trj.setClassification("n");				// predicted class
		trj.setName("20");
		dataset.add(trj);
		
		
		return dataset;
	}