public DefaultStatisticalCategoryDataset() 
{
        this.data = new KeyedObjects2D();
        this.minimumRangeValue = Double.NaN;
        this.minimumRangeValueRow = -1;
        this.minimumRangeValueColumn = -1;
        this.maximumRangeValue = Double.NaN;
        this.maximumRangeValueRow = -1;
        this.maximumRangeValueColumn = -1;
        this.minimumRangeValueIncStdDev = Double.NaN;
        this.minimumRangeValueIncStdDevRow = -1;
        this.minimumRangeValueIncStdDevColumn = -1;
        this.maximumRangeValueIncStdDev = Double.NaN;
        this.maximumRangeValueIncStdDevRow = -1;
        this.maximumRangeValueIncStdDevColumn = -1;
}

Creates a new dataset.

 public  void add(double mean,
    double standardDeviation,
    Comparable rowKey,
    Comparable columnKey) 
{
        add(new Double(mean), new Double(standardDeviation), rowKey, columnKey);
}

Adds a mean and standard deviation to the table.

 public  void add(Number mean,
    Number standardDeviation,
    Comparable rowKey,
    Comparable columnKey) 
{
        MeanAndStandardDeviation item = new MeanAndStandardDeviation(
                mean, standardDeviation);
        this.data.addObject(item, rowKey, columnKey);
        double m = Double.NaN;
        double sd = Double.NaN;
        if (mean != null) {
            m = mean.doubleValue();
        }
        if (standardDeviation != null) {
            sd = standardDeviation.doubleValue();   
        }
        // update cached range values
        int r = this.data.getColumnIndex(columnKey);
        int c = this.data.getRowIndex(rowKey);
        if ((r == this.maximumRangeValueRow && c 
                == this.maximumRangeValueColumn) || (r 
                == this.maximumRangeValueIncStdDevRow && c 
                == this.maximumRangeValueIncStdDevColumn) || (r 
                == this.minimumRangeValueRow && c 
                == this.minimumRangeValueColumn) || (r 
                == this.minimumRangeValueIncStdDevRow && c 
                == this.minimumRangeValueIncStdDevColumn)) {
            // iterate over all data items and update mins and maxes
            updateBounds();
        } 
        else {
            if (!Double.isNaN(m)) {
                if (Double.isNaN(this.maximumRangeValue) 
                        || m  > this.maximumRangeValue) {
                    this.maximumRangeValue = m;
                    this.maximumRangeValueRow = r;
                    this.maximumRangeValueColumn = c;
                }
            }
            if (!Double.isNaN(m + sd)) {
                if (Double.isNaN(this.maximumRangeValueIncStdDev) 
                        || (m + sd)  > this.maximumRangeValueIncStdDev) {
                    this.maximumRangeValueIncStdDev = m + sd;
                    this.maximumRangeValueIncStdDevRow = r;
                    this.maximumRangeValueIncStdDevColumn = c;
                }
            }
            if (!Double.isNaN(m)) {
                if (Double.isNaN(this.minimumRangeValue) 
                        || m <  this.minimumRangeValue) {
                    this.minimumRangeValue = m;
                    this.minimumRangeValueRow = r;
                    this.minimumRangeValueColumn = c;
                }
            }
            if (!Double.isNaN(m - sd)) {
                if (Double.isNaN(this.minimumRangeValueIncStdDev) 
                        || (m - sd) <  this.minimumRangeValueIncStdDev) {
                    this.minimumRangeValueIncStdDev = m - sd;
                    this.minimumRangeValueIncStdDevRow = r;
                    this.minimumRangeValueIncStdDevColumn = c;
                }
            }
        }
        fireDatasetChanged();
}

Adds a mean and standard deviation to the table.

 public  void clear() 
{
        this.data.clear();
        updateBounds();
        fireDatasetChanged();
}

Clears all data from the dataset and sends a DatasetChangeEvent to all registered listeners.

 public Object clone() throws CloneNotSupportedException 
{
        DefaultStatisticalCategoryDataset clone 
                = (DefaultStatisticalCategoryDataset) super.clone();
        clone.data = (KeyedObjects2D) this.data.clone();
        return clone;
}

Returns a clone of this dataset.

 public boolean equals(Object obj) 
{
        if (obj == this) {
            return true;   
        }
        if (!(obj instanceof DefaultStatisticalCategoryDataset)) {
            return false;   
        }
        DefaultStatisticalCategoryDataset that 
                = (DefaultStatisticalCategoryDataset) obj;
        if (!this.data.equals(that.data)) {
            return false;   
        }
        return true;
}

Tests this instance for equality with an arbitrary object.

 public int getColumnCount() 
{
        return this.data.getColumnCount();
}

Returns the number of columns in the table.

 public int getColumnIndex(Comparable key) 
{
        // defer null argument check
        return this.data.getColumnIndex(key);
}

Returns the column index for a given key.

 public Comparable getColumnKey(int column) 
{
        return this.data.getColumnKey(column);
}

Returns a column key.

 public List getColumnKeys() 
{
        return this.data.getColumnKeys();
}

Returns the column keys.

 public Number getMeanValue(int row,
    int column) 
{
        Number result = null;
        MeanAndStandardDeviation masd = (MeanAndStandardDeviation) 
                this.data.getObject(row, column);
        if (masd != null) {
            result = masd.getMean();
        }
        return result;
}

Returns the mean value for an item.

 public Number getMeanValue(Comparable rowKey,
    Comparable columnKey) 
{
        Number result = null;
        MeanAndStandardDeviation masd = (MeanAndStandardDeviation) 
                this.data.getObject(rowKey, columnKey);
        if (masd != null) {
            result = masd.getMean();
        }
        return result;
}

Returns the mean value for an item.

 public Range getRangeBounds(boolean includeInterval) 
{
        Range result = null;
        if (includeInterval) {
            if (!Double.isNaN(this.minimumRangeValueIncStdDev) 
                    && !Double.isNaN(this.maximumRangeValueIncStdDev)) {
                result = new Range(this.minimumRangeValueIncStdDev, 
                        this.maximumRangeValueIncStdDev);
            }
        }
        else {
            if (!Double.isNaN(this.minimumRangeValue) 
                    && !Double.isNaN(this.maximumRangeValue)) {
                result = new Range(this.minimumRangeValue, 
                        this.maximumRangeValue);
            }
        }
        return result;
}

Returns the range of the values in this dataset's range.

 public double getRangeLowerBound(boolean includeInterval) 
{
        if (includeInterval) {
            return this.minimumRangeValueIncStdDev;
        }
        else {
            return this.minimumRangeValue;     
        }
}

Returns the minimum y-value in the dataset.

 public double getRangeUpperBound(boolean includeInterval) 
{
        if (includeInterval) {
            return this.maximumRangeValueIncStdDev;
        }
        else {
            return this.maximumRangeValue;     
        }
}

Returns the maximum y-value in the dataset.

 public int getRowCount() 
{
        return this.data.getRowCount();
}

Returns the number of rows in the table.

 public int getRowIndex(Comparable key) 
{
        // defer null argument check
        return this.data.getRowIndex(key);
}

Returns the row index for a given key.

 public Comparable getRowKey(int row) 
{
        return this.data.getRowKey(row);
}

Returns a row key.

 public List getRowKeys() 
{
        return this.data.getRowKeys();
}

Returns the row keys.

 public Number getStdDevValue(int row,
    int column) 
{
        Number result = null;
        MeanAndStandardDeviation masd = (MeanAndStandardDeviation) 
                this.data.getObject(row, column);
        if (masd != null) {
            result = masd.getStandardDeviation();
        }
        return result;
}

Returns the standard deviation value for an item.

 public Number getStdDevValue(Comparable rowKey,
    Comparable columnKey) 
{
        Number result = null;
        MeanAndStandardDeviation masd = (MeanAndStandardDeviation) 
                this.data.getObject(rowKey, columnKey);
        if (masd != null) {
            result = masd.getStandardDeviation();
        }
        return result;
}

Returns the standard deviation value for an item.

 public Number getValue(int row,
    int column) 
{
        return getMeanValue(row, column);
}

Returns the value for an item (for this dataset, the mean value is returned).

 public Number getValue(Comparable rowKey,
    Comparable columnKey) 
{
        return getMeanValue(rowKey, columnKey);
}

Returns the value for an item (for this dataset, the mean value is returned).

 public  void remove(Comparable rowKey,
    Comparable columnKey) 
{
        // defer null argument checks
        int r = getRowIndex(rowKey);
        int c = getColumnIndex(columnKey);
        this.data.removeObject(rowKey, columnKey);
        // if this cell held a maximum and/or minimum value, we'll need to
        // update the cached bounds...
        if ((r == this.maximumRangeValueRow && c 
                == this.maximumRangeValueColumn) || (r 
                == this.maximumRangeValueIncStdDevRow && c 
                == this.maximumRangeValueIncStdDevColumn) || (r 
                == this.minimumRangeValueRow && c 
                == this.minimumRangeValueColumn) || (r 
                == this.minimumRangeValueIncStdDevRow && c 
                == this.minimumRangeValueIncStdDevColumn)) {
            // iterate over all data items and update mins and maxes
            updateBounds();
        } 
        fireDatasetChanged();
}

Removes an item from the dataset and sends a DatasetChangeEvent to all registered listeners.

 public  void removeColumn(int columnIndex) 
{
        this.data.removeColumn(columnIndex);
        updateBounds();
        fireDatasetChanged();
}

Removes a column from the dataset and sends a DatasetChangeEvent to all registered listeners.

 public  void removeColumn(Comparable columnKey) 
{
        this.data.removeColumn(columnKey);
        updateBounds();
        fireDatasetChanged();
}

Removes a column from the dataset and sends a DatasetChangeEvent to all registered listeners.

 public  void removeRow(int rowIndex) 
{
        this.data.removeRow(rowIndex);
        updateBounds();
        fireDatasetChanged();
}

Removes a row from the dataset and sends a DatasetChangeEvent to all registered listeners.

 public  void removeRow(Comparable rowKey) 
{
        this.data.removeRow(rowKey);
        updateBounds();
        fireDatasetChanged();
}

Removes a row from the dataset and sends a DatasetChangeEvent to all registered listeners.