private double calcSTDev(
HashMap<Integer, String> singleGeneCaseValueMap, String groupType, String profileStableId) {
switch (groupType) {
case "altered":
DescriptiveStatistics stats_altered = new DescriptiveStatistics();
for (Integer alteredSampleId : alteredSampleIds) {
if (singleGeneCaseValueMap.containsKey(alteredSampleId)) {
if (profileStableId.indexOf("rna_seq") != -1) {
try {
stats_altered.addValue(
Math.log(Double.parseDouble(singleGeneCaseValueMap.get(alteredSampleId)))
/ Math.log(2));
} catch (NumberFormatException e) {
e.getStackTrace();
}
} else {
try {
stats_altered.addValue(
Double.parseDouble(singleGeneCaseValueMap.get(alteredSampleId)));
} catch (NumberFormatException e) {
e.getStackTrace();
}
}
}
}
return stats_altered.getStandardDeviation();
case "unaltered":
DescriptiveStatistics stats_unaltered = new DescriptiveStatistics();
for (Integer unalteredSampleId : unalteredSampleIds) {
if (singleGeneCaseValueMap.containsKey(unalteredSampleId)) {
if (profileStableId.indexOf("rna_seq") != -1) {
try {
stats_unaltered.addValue(
Math.log(Double.parseDouble(singleGeneCaseValueMap.get(unalteredSampleId)))
/ Math.log(2));
} catch (NumberFormatException e) {
e.getStackTrace();
}
} else {
try {
stats_unaltered.addValue(
Double.parseDouble(singleGeneCaseValueMap.get(unalteredSampleId)));
} catch (NumberFormatException e) {
e.getStackTrace();
}
}
}
}
return stats_unaltered.getStandardDeviation();
default:
return Double.NaN; // error
}
}
/**
* Normalize (standardize) the sample, so it is has a mean of 0 and a standard deviation of 1.
*
* @param sample Sample to normalize.
* @return normalized (standardized) sample.
* @since 2.2
*/
public static double[] normalize(final double[] sample) {
DescriptiveStatistics stats = new DescriptiveStatistics();
// Add the data from the series to stats
for (int i = 0; i < sample.length; i++) {
stats.addValue(sample[i]);
}
// Compute mean and standard deviation
double mean = stats.getMean();
double standardDeviation = stats.getStandardDeviation();
// initialize the standardizedSample, which has the same length as the sample
double[] standardizedSample = new double[sample.length];
for (int i = 0; i < sample.length; i++) {
// z = (x- mean)/standardDeviation
standardizedSample[i] = (sample[i] - mean) / standardDeviation;
}
return standardizedSample;
}
public Vector<double[]> getMeanSd(svm_node[][] node) {
// TODO Auto-generated method stub
DescriptiveStatistics statistics = new DescriptiveStatistics();
int nAttr = node[0].length;
int nSample = node.length;
double[] meanValues = new double[nAttr];
double[] sdValues = new double[nAttr];
for (int i = 0; i < nAttr; i++) {
statistics.clear();
for (int j = 0; j < nSample; j++) {
statistics.addValue(node[j][i].value);
}
// 获取中值及标准差
meanValues[i] = statistics.getMean();
sdValues[i] = statistics.getStandardDeviation();
}
Vector<double[]> meanSd = new Vector<double[]>();
meanSd.add(meanValues);
meanSd.add(sdValues);
return meanSd;
}
public static void main(String[] args) {
// TEST MEASURE
// Point p1 = new Point(-1d, -1d);
// Point p2 = new Point(2d, 3d);
// System.out.println(measure.d(p1, p2));
// System.out.println(measure.s(p1, p2));
// return;
Double[][] data = FileHandler.readFile(fileName);
// cannot display points if dimension is > 2
if (data[0].length != 2) canDisplay = false;
// build graphic points from coords' array
buildPointsFromData(data);
Config.computeBoundingRect(points);
// init display
if (canDisplay) {
disp = new Display();
disp.setVisible(true);
for (Point p : points) {
disp.addObject(p);
}
}
testResults = new double[nbTests];
for (int t = 0; t < nbTests; ++t) {
// define K clusters and K temporary centres
clusters = new ArrayList<Cluster>();
for (int i = 0; i < K; ++i) {
clusters.add(new Cluster());
}
setRandomCenters();
for (Cluster c : clusters) {
System.out.println("center for cluster " + c + ": " + c.getCenter());
}
if (canDisplay) pause(1000);
// variables used in for loops
double minDist, currDist, diff;
Double[] prevCoords, newCoords;
Cluster alloc;
Point newCenter;
for (int i = 0; i < maxIter; ++i) {
if (canDisplay) {
disp.setLabel("[ iteration #" + (i + 1) + " ]");
} else {
System.out.println("------> iteration #" + (i + 1));
}
// allocate points to group which center is closest
for (Point p : points) {
minDist = Config.MAX;
alloc = clusters.get(0); // default initialization
for (Cluster c : clusters) {
currDist = measure.d(p, c.getCenter());
if (currDist < minDist) {
minDist = currDist;
alloc = c;
}
}
alloc.addPoint(p);
}
// recenter: calculate gravity centers for formed groups
diff = 0;
prevCoords = null;
for (Cluster c : clusters) {
// delete previous center if it not a Point of the Cluster
if (canDisplay && !c.getPoints().contains(c.getCenter())) {
disp.removeObject(c.getCenter());
}
if (stopOnConverge) {
prevCoords = c.getCenter().getCoords();
}
newCenter = c.makeGravityCenter();
if (stopOnConverge) {
newCoords = c.getCenter().getCoords();
for (int k = 0; k < prevCoords.length; ++k) {
diff += Math.abs(prevCoords[k] - newCoords[k]);
}
}
if (canDisplay) {
disp.addObject(newCenter);
} else {
// System.out.println("\tcenter for " + c + ": " + c.getCenter());
System.out.println(c.getCenter());
}
} // loop over clusters
if (canDisplay) {
disp.repaint();
}
// if Clusters' centers don't change anymore, then stop (algorithm converged)
if (diff == 0 && stopOnConverge) {
testResults[t] = (double) i;
if (canDisplay) {
disp.setLabel("[ Converged at iteration #" + (i) + " ]");
disp.repaint();
} else {
System.out.println("[ Converged at iteration #" + (i) + " ]");
}
break;
}
pause(100);
} // loop over iterations
if (testResults[t] == 0) {
System.out.println("!!!!!!!!!! Test #" + t + " did not converge.");
if (stopOnConverge) return;
}
// reset display
if (canDisplay && t + 1 < nbTests) {
for (Point p : points) p.setCluster(null);
for (Cluster c : clusters) disp.removeObject(c.getCenter());
}
} // loop over tests
// display test results and compute means
DescriptiveStatistics stats = new DescriptiveStatistics(testResults);
System.out.println("=========> Results:");
for (int t = 0; t < nbTests; ++t) {
System.out.println("--> [ " + testResults[t] + " ]");
}
System.out.println("=========> Means: " + stats.getMean());
System.out.println("=========> Std dev: " + stats.getStandardDeviation());
}
