1:
55:
56: package ;
57:
58: import ;
59:
60: import ;
61: import ;
62: import ;
63: import ;
64: import ;
65: import ;
66:
67:
71: public class DefaultStatisticalCategoryDataset extends AbstractDataset
72: implements StatisticalCategoryDataset, RangeInfo, PublicCloneable {
73:
74:
75: private KeyedObjects2D data;
76:
77:
78: private double minimumRangeValue;
79:
80:
81: private int minimumRangeValueRow;
82:
83:
84: private int minimumRangeValueColumn;
85:
86:
87: private double minimumRangeValueIncStdDev;
88:
89:
93: private int minimumRangeValueIncStdDevRow;
94:
95:
99: private int minimumRangeValueIncStdDevColumn;
100:
101:
102: private double maximumRangeValue;
103:
104:
105: private int maximumRangeValueRow;
106:
107:
108: private int maximumRangeValueColumn;
109:
110:
111: private double maximumRangeValueIncStdDev;
112:
113:
117: private int maximumRangeValueIncStdDevRow;
118:
119:
123: private int maximumRangeValueIncStdDevColumn;
124:
125:
128: public DefaultStatisticalCategoryDataset() {
129: this.data = new KeyedObjects2D();
130: this.minimumRangeValue = Double.NaN;
131: this.minimumRangeValueRow = -1;
132: this.minimumRangeValueColumn = -1;
133: this.maximumRangeValue = Double.NaN;
134: this.maximumRangeValueRow = -1;
135: this.maximumRangeValueColumn = -1;
136: this.minimumRangeValueIncStdDev = Double.NaN;
137: this.minimumRangeValueIncStdDevRow = -1;
138: this.minimumRangeValueIncStdDevColumn = -1;
139: this.maximumRangeValueIncStdDev = Double.NaN;
140: this.maximumRangeValueIncStdDevRow = -1;
141: this.maximumRangeValueIncStdDevColumn = -1;
142: }
143:
144:
152: public Number getMeanValue(int row, int column) {
153: Number result = null;
154: MeanAndStandardDeviation masd = (MeanAndStandardDeviation)
155: this.data.getObject(row, column);
156: if (masd != null) {
157: result = masd.getMean();
158: }
159: return result;
160: }
161:
162:
171: public Number getValue(int row, int column) {
172: return getMeanValue(row, column);
173: }
174:
175:
184: public Number getValue(Comparable rowKey, Comparable columnKey) {
185: return getMeanValue(rowKey, columnKey);
186: }
187:
188:
196: public Number getMeanValue(Comparable rowKey, Comparable columnKey) {
197: Number result = null;
198: MeanAndStandardDeviation masd = (MeanAndStandardDeviation)
199: this.data.getObject(rowKey, columnKey);
200: if (masd != null) {
201: result = masd.getMean();
202: }
203: return result;
204: }
205:
206:
214: public Number getStdDevValue(int row, int column) {
215: Number result = null;
216: MeanAndStandardDeviation masd = (MeanAndStandardDeviation)
217: this.data.getObject(row, column);
218: if (masd != null) {
219: result = masd.getStandardDeviation();
220: }
221: return result;
222: }
223:
224:
232: public Number getStdDevValue(Comparable rowKey, Comparable columnKey) {
233: Number result = null;
234: MeanAndStandardDeviation masd = (MeanAndStandardDeviation)
235: this.data.getObject(rowKey, columnKey);
236: if (masd != null) {
237: result = masd.getStandardDeviation();
238: }
239: return result;
240: }
241:
242:
249: public int getColumnIndex(Comparable key) {
250:
251: return this.data.getColumnIndex(key);
252: }
253:
254:
261: public Comparable getColumnKey(int column) {
262: return this.data.getColumnKey(column);
263: }
264:
265:
270: public List getColumnKeys() {
271: return this.data.getColumnKeys();
272: }
273:
274:
281: public int getRowIndex(Comparable key) {
282:
283: return this.data.getRowIndex(key);
284: }
285:
286:
293: public Comparable getRowKey(int row) {
294: return this.data.getRowKey(row);
295: }
296:
297:
302: public List getRowKeys() {
303: return this.data.getRowKeys();
304: }
305:
306:
313: public int getRowCount() {
314: return this.data.getRowCount();
315: }
316:
317:
324: public int getColumnCount() {
325: return this.data.getColumnCount();
326: }
327:
328:
336: public void add(double mean, double standardDeviation,
337: Comparable rowKey, Comparable columnKey) {
338: add(new Double(mean), new Double(standardDeviation), rowKey, columnKey);
339: }
340:
341:
349: public void add(Number mean, Number standardDeviation,
350: Comparable rowKey, Comparable columnKey) {
351: MeanAndStandardDeviation item = new MeanAndStandardDeviation(
352: mean, standardDeviation);
353: this.data.addObject(item, rowKey, columnKey);
354:
355: double m = Double.NaN;
356: double sd = Double.NaN;
357: if (mean != null) {
358: m = mean.doubleValue();
359: }
360: if (standardDeviation != null) {
361: sd = standardDeviation.doubleValue();
362: }
363:
364:
365: int r = this.data.getColumnIndex(columnKey);
366: int c = this.data.getRowIndex(rowKey);
367: if ((r == this.maximumRangeValueRow && c
368: == this.maximumRangeValueColumn) || (r
369: == this.maximumRangeValueIncStdDevRow && c
370: == this.maximumRangeValueIncStdDevColumn) || (r
371: == this.minimumRangeValueRow && c
372: == this.minimumRangeValueColumn) || (r
373: == this.minimumRangeValueIncStdDevRow && c
374: == this.minimumRangeValueIncStdDevColumn)) {
375:
376:
377: updateBounds();
378: }
379: else {
380: if (!Double.isNaN(m)) {
381: if (Double.isNaN(this.maximumRangeValue)
382: || m > this.maximumRangeValue) {
383: this.maximumRangeValue = m;
384: this.maximumRangeValueRow = r;
385: this.maximumRangeValueColumn = c;
386: }
387: }
388:
389: if (!Double.isNaN(m + sd)) {
390: if (Double.isNaN(this.maximumRangeValueIncStdDev)
391: || (m + sd) > this.maximumRangeValueIncStdDev) {
392: this.maximumRangeValueIncStdDev = m + sd;
393: this.maximumRangeValueIncStdDevRow = r;
394: this.maximumRangeValueIncStdDevColumn = c;
395: }
396: }
397:
398: if (!Double.isNaN(m)) {
399: if (Double.isNaN(this.minimumRangeValue)
400: || m < this.minimumRangeValue) {
401: this.minimumRangeValue = m;
402: this.minimumRangeValueRow = r;
403: this.minimumRangeValueColumn = c;
404: }
405: }
406:
407: if (!Double.isNaN(m - sd)) {
408: if (Double.isNaN(this.minimumRangeValueIncStdDev)
409: || (m - sd) < this.minimumRangeValueIncStdDev) {
410: this.minimumRangeValueIncStdDev = m - sd;
411: this.minimumRangeValueIncStdDevRow = r;
412: this.minimumRangeValueIncStdDevColumn = c;
413: }
414: }
415: }
416: fireDatasetChanged();
417: }
418:
419:
430: public void remove(Comparable rowKey, Comparable columnKey) {
431:
432: int r = getRowIndex(rowKey);
433: int c = getColumnIndex(columnKey);
434: this.data.removeObject(rowKey, columnKey);
435:
436:
437:
438: if ((r == this.maximumRangeValueRow && c
439: == this.maximumRangeValueColumn) || (r
440: == this.maximumRangeValueIncStdDevRow && c
441: == this.maximumRangeValueIncStdDevColumn) || (r
442: == this.minimumRangeValueRow && c
443: == this.minimumRangeValueColumn) || (r
444: == this.minimumRangeValueIncStdDevRow && c
445: == this.minimumRangeValueIncStdDevColumn)) {
446:
447:
448: updateBounds();
449: }
450:
451: fireDatasetChanged();
452: }
453:
454:
455:
465: public void removeRow(int rowIndex) {
466: this.data.removeRow(rowIndex);
467: updateBounds();
468: fireDatasetChanged();
469: }
470:
471:
481: public void removeRow(Comparable rowKey) {
482: this.data.removeRow(rowKey);
483: updateBounds();
484: fireDatasetChanged();
485: }
486:
487:
497: public void removeColumn(int columnIndex) {
498: this.data.removeColumn(columnIndex);
499: updateBounds();
500: fireDatasetChanged();
501: }
502:
503:
513: public void removeColumn(Comparable columnKey) {
514: this.data.removeColumn(columnKey);
515: updateBounds();
516: fireDatasetChanged();
517: }
518:
519:
525: public void clear() {
526: this.data.clear();
527: updateBounds();
528: fireDatasetChanged();
529: }
530:
531:
534: private void updateBounds() {
535: this.maximumRangeValue = Double.NaN;
536: this.maximumRangeValueRow = -1;
537: this.maximumRangeValueColumn = -1;
538: this.minimumRangeValue = Double.NaN;
539: this.minimumRangeValueRow = -1;
540: this.minimumRangeValueColumn = -1;
541: this.maximumRangeValueIncStdDev = Double.NaN;
542: this.maximumRangeValueIncStdDevRow = -1;
543: this.maximumRangeValueIncStdDevColumn = -1;
544: this.minimumRangeValueIncStdDev = Double.NaN;
545: this.minimumRangeValueIncStdDevRow = -1;
546: this.minimumRangeValueIncStdDevColumn = -1;
547:
548: int rowCount = this.data.getRowCount();
549: int columnCount = this.data.getColumnCount();
550: for (int r = 0; r < rowCount; r++) {
551: for (int c = 0; c < columnCount; c++) {
552: double m = Double.NaN;
553: double sd = Double.NaN;
554: MeanAndStandardDeviation masd = (MeanAndStandardDeviation)
555: this.data.getObject(r, c);
556: if (masd == null) {
557: continue;
558: }
559: m = masd.getMeanValue();
560: sd = masd.getStandardDeviationValue();
561:
562: if (!Double.isNaN(m)) {
563:
564:
565: if (Double.isNaN(this.maximumRangeValue)) {
566: this.maximumRangeValue = m;
567: this.maximumRangeValueRow = r;
568: this.maximumRangeValueColumn = c;
569: }
570: else {
571: if (m > this.maximumRangeValue) {
572: this.maximumRangeValue = m;
573: this.maximumRangeValueRow = r;
574: this.maximumRangeValueColumn = c;
575: }
576: }
577:
578:
579: if (Double.isNaN(this.minimumRangeValue)) {
580: this.minimumRangeValue = m;
581: this.minimumRangeValueRow = r;
582: this.minimumRangeValueColumn = c;
583: }
584: else {
585: if (m < this.minimumRangeValue) {
586: this.minimumRangeValue = m;
587: this.minimumRangeValueRow = r;
588: this.minimumRangeValueColumn = c;
589: }
590: }
591:
592: if (!Double.isNaN(sd)) {
593:
594: if (Double.isNaN(this.maximumRangeValueIncStdDev)) {
595: this.maximumRangeValueIncStdDev = m + sd;
596: this.maximumRangeValueIncStdDevRow = r;
597: this.maximumRangeValueIncStdDevColumn = c;
598: }
599: else {
600: if (m + sd > this.maximumRangeValueIncStdDev) {
601: this.maximumRangeValueIncStdDev = m + sd;
602: this.maximumRangeValueIncStdDevRow = r;
603: this.maximumRangeValueIncStdDevColumn = c;
604: }
605: }
606:
607:
608: if (Double.isNaN(this.minimumRangeValueIncStdDev)) {
609: this.minimumRangeValueIncStdDev = m - sd;
610: this.minimumRangeValueIncStdDevRow = r;
611: this.minimumRangeValueIncStdDevColumn = c;
612: }
613: else {
614: if (m - sd < this.minimumRangeValueIncStdDev) {
615: this.minimumRangeValueIncStdDev = m - sd;
616: this.minimumRangeValueIncStdDevRow = r;
617: this.minimumRangeValueIncStdDevColumn = c;
618: }
619: }
620: }
621: }
622: }
623: }
624: }
625:
626:
636: public double getRangeLowerBound(boolean includeInterval) {
637: if (includeInterval) {
638: return this.minimumRangeValueIncStdDev;
639: }
640: else {
641: return this.minimumRangeValue;
642: }
643: }
644:
645:
655: public double getRangeUpperBound(boolean includeInterval) {
656: if (includeInterval) {
657: return this.maximumRangeValueIncStdDev;
658: }
659: else {
660: return this.maximumRangeValue;
661: }
662: }
663:
664:
672: public Range getRangeBounds(boolean includeInterval) {
673: Range result = null;
674: if (includeInterval) {
675: if (!Double.isNaN(this.minimumRangeValueIncStdDev)
676: && !Double.isNaN(this.maximumRangeValueIncStdDev)) {
677: result = new Range(this.minimumRangeValueIncStdDev,
678: this.maximumRangeValueIncStdDev);
679: }
680: }
681: else {
682: if (!Double.isNaN(this.minimumRangeValue)
683: && !Double.isNaN(this.maximumRangeValue)) {
684: result = new Range(this.minimumRangeValue,
685: this.maximumRangeValue);
686: }
687: }
688: return result;
689: }
690:
691:
698: public boolean equals(Object obj) {
699: if (obj == this) {
700: return true;
701: }
702: if (!(obj instanceof DefaultStatisticalCategoryDataset)) {
703: return false;
704: }
705: DefaultStatisticalCategoryDataset that
706: = (DefaultStatisticalCategoryDataset) obj;
707: if (!this.data.equals(that.data)) {
708: return false;
709: }
710: return true;
711: }
712:
713:
720: public Object clone() throws CloneNotSupportedException {
721: DefaultStatisticalCategoryDataset clone
722: = (DefaultStatisticalCategoryDataset) super.clone();
723: clone.data = (KeyedObjects2D) this.data.clone();
724: return clone;
725: }
726: }