1:
50:
51: package ;
52:
53: import ;
54: import ;
55: import ;
56: import ;
57: import ;
58:
59:
62: public abstract class Statistics {
63:
64:
72: public static double calculateMean(Number[] values) {
73: double result = Double.NaN;
74: if (values != null && values.length > 0) {
75: double sum = 0.0;
76: int counter = 0;
77: for (; counter < values.length; counter++) {
78: sum = sum + values[counter].doubleValue();
79: }
80: result = (sum / counter);
81: }
82: return result;
83: }
84:
85:
93: public static double calculateMean(Collection values) {
94:
95: double result = Double.NaN;
96: int count = 0;
97: double total = 0.0;
98: Iterator iterator = values.iterator();
99: while (iterator.hasNext()) {
100: Object object = iterator.next();
101: if (object != null && object instanceof Number) {
102: Number number = (Number) object;
103: total = total + number.doubleValue();
104: count = count + 1;
105: }
106: }
107: if (count > 0) {
108: result = total / count;
109: }
110: return result;
111:
112: }
113:
114:
122: public static double calculateMedian(List values) {
123: return calculateMedian(values, true);
124: }
125:
126:
136: public static double calculateMedian(List values, boolean copyAndSort) {
137:
138: double result = Double.NaN;
139: if (values != null) {
140: if (copyAndSort) {
141: int itemCount = values.size();
142: List copy = new ArrayList(itemCount);
143: for (int i = 0; i < itemCount; i++) {
144: copy.add(i, values.get(i));
145: }
146: Collections.sort(copy);
147: values = copy;
148: }
149: int count = values.size();
150: if (count > 0) {
151: if (count % 2 == 1) {
152: if (count > 1) {
153: Number value = (Number) values.get((count - 1) / 2);
154: result = value.doubleValue();
155: }
156: else {
157: Number value = (Number) values.get(0);
158: result = value.doubleValue();
159: }
160: }
161: else {
162: Number value1 = (Number) values.get(count / 2 - 1);
163: Number value2 = (Number) values.get(count / 2);
164: result = (value1.doubleValue() + value2.doubleValue())
165: / 2.0;
166: }
167: }
168: }
169: return result;
170: }
171:
172:
182: public static double calculateMedian(List values, int start, int end) {
183: return calculateMedian(values, start, end, true);
184: }
185:
186:
199: public static double calculateMedian(List values, int start, int end,
200: boolean copyAndSort) {
201:
202: double result = Double.NaN;
203: if (copyAndSort) {
204: List working = new ArrayList(end - start + 1);
205: for (int i = start; i <= end; i++) {
206: working.add(values.get(i));
207: }
208: Collections.sort(working);
209: result = calculateMedian(working, false);
210: }
211: else {
212: int count = end - start + 1;
213: if (count > 0) {
214: if (count % 2 == 1) {
215: if (count > 1) {
216: Number value
217: = (Number) values.get(start + (count - 1) / 2);
218: result = value.doubleValue();
219: }
220: else {
221: Number value = (Number) values.get(start);
222: result = value.doubleValue();
223: }
224: }
225: else {
226: Number value1 = (Number) values.get(start + count / 2 - 1);
227: Number value2 = (Number) values.get(start + count / 2);
228: result
229: = (value1.doubleValue() + value2.doubleValue()) / 2.0;
230: }
231: }
232: }
233: return result;
234:
235: }
236:
237:
244: public static double getStdDev(Number[] data) {
245: double avg = calculateMean(data);
246: double sum = 0.0;
247:
248: for (int counter = 0; counter < data.length; counter++) {
249: double diff = data[counter].doubleValue() - avg;
250: sum = sum + diff * diff;
251: }
252: return Math.sqrt(sum / (data.length - 1));
253: }
254:
255:
264: public static double[] getLinearFit(Number[] xData, Number[] yData) {
265:
266:
267: if (xData.length != yData.length) {
268: throw new IllegalArgumentException(
269: "Statistics.getLinearFit(): array lengths must be equal.");
270: }
271:
272: double[] result = new double[2];
273:
274: result[1] = getSlope(xData, yData);
275:
276: result[0] = calculateMean(yData) - result[1] * calculateMean(xData);
277:
278: return result;
279:
280: }
281:
282:
290: public static double getSlope(Number[] xData, Number[] yData) {
291:
292:
293: if (xData.length != yData.length) {
294: throw new IllegalArgumentException("Array lengths must be equal.");
295: }
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306: double sx = 0.0, sxx = 0.0, sxy = 0.0, sy = 0.0;
307: int counter;
308: for (counter = 0; counter < xData.length; counter++) {
309: sx = sx + xData[counter].doubleValue();
310: sxx = sxx + Math.pow(xData[counter].doubleValue(), 2);
311: sxy = sxy + yData[counter].doubleValue()
312: * xData[counter].doubleValue();
313: sy = sy + yData[counter].doubleValue();
314: }
315: return (sxy - (sx * sy) / counter) / (sxx - (sx * sx) / counter);
316:
317: }
318:
319:
332: public static double getCorrelation(Number[] data1, Number[] data2) {
333: if (data1 == null) {
334: throw new IllegalArgumentException("Null 'data1' argument.");
335: }
336: if (data2 == null) {
337: throw new IllegalArgumentException("Null 'data2' argument.");
338: }
339: if (data1.length != data2.length) {
340: throw new IllegalArgumentException(
341: "'data1' and 'data2' arrays must have same length."
342: );
343: }
344: int n = data1.length;
345: double sumX = 0.0;
346: double sumY = 0.0;
347: double sumX2 = 0.0;
348: double sumY2 = 0.0;
349: double sumXY = 0.0;
350: for (int i = 0; i < n; i++) {
351: double x = 0.0;
352: if (data1[i] != null) {
353: x = data1[i].doubleValue();
354: }
355: double y = 0.0;
356: if (data2[i] != null) {
357: y = data2[i].doubleValue();
358: }
359: sumX = sumX + x;
360: sumY = sumY + y;
361: sumXY = sumXY + (x * y);
362: sumX2 = sumX2 + (x * x);
363: sumY2 = sumY2 + (y * y);
364: }
365: return (n * sumXY - sumX * sumY) / Math.pow((n * sumX2 - sumX * sumX)
366: * (n * sumY2 - sumY * sumY), 0.5);
367: }
368:
369:
379: public static double[][] getMovingAverage(Number[] xData,
380: Number[] yData,
381: int period) {
382:
383:
384: if (xData.length != yData.length) {
385: throw new IllegalArgumentException("Array lengths must be equal.");
386: }
387:
388: if (period > xData.length) {
389: throw new IllegalArgumentException(
390: "Period can't be longer than dataset."
391: );
392: }
393:
394: double[][] result = new double[xData.length - period][2];
395: for (int i = 0; i < result.length; i++) {
396: result[i][0] = xData[i + period].doubleValue();
397:
398: double sum = 0.0;
399: for (int j = 0; j < period; j++) {
400: sum += yData[i + j].doubleValue();
401: }
402: sum = sum / period;
403: result[i][1] = sum;
404: }
405: return result;
406:
407: }
408:
409: }