📄 datasetutilities.java
字号:
/* ======================================
* JFreeChart : a free Java chart library
* ======================================
*
* Project Info: http://www.jfree.org/jfreechart/index.html
* Project Lead: David Gilbert (david.gilbert@object-refinery.com);
*
* (C) Copyright 2000-2003, by Object Refinery Limited and Contributors.
*
* This library is free software; you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Foundation;
* either version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* ---------------------
* DatasetUtilities.java
* ---------------------
* (C) Copyright 2000-2003, by Object Refinery Limited and Contributors.
*
* Original Author: David Gilbert (for Object Refinery Limited);
* Contributor(s): Andrzej Porebski (bug fix);
* Jonathan Nash (bug fix);
* Richard Atkinson;
*
* $Id: DatasetUtilities.java,v 1.14 2003/09/03 15:08:51 mungady Exp $
*
* Changes (from 18-Sep-2001)
* --------------------------
* 18-Sep-2001 : Added standard header and fixed DOS encoding problem (DG);
* 22-Oct-2001 : Renamed DataSource.java --> Dataset.java etc. (DG);
* 15-Nov-2001 : Moved to package com.jrefinery.data.* in the JCommon class library (DG);
* Changed to handle null values from datasets (DG);
* Bug fix (thanks to Andrzej Porebski) - initial value now set to positive or
* negative infinity when iterating (DG);
* 22-Nov-2001 : Datasets with containing no data now return null for min and max calculations (DG);
* 13-Dec-2001 : Extended to handle HighLowDataset and IntervalXYDataset (DG);
* 15-Feb-2002 : Added getMinimumStackedRangeValue() and getMaximumStackedRangeValue() (DG);
* 28-Feb-2002 : Renamed Datasets.java --> DatasetUtilities.java (DG);
* 18-Mar-2002 : Fixed bug in min/max domain calculation for datasets that implement the
* CategoryDataset interface AND the XYDataset interface at the same time. Thanks
* to Jonathan Nash for the fix (DG);
* 23-Apr-2002 : Added getDomainExtent() and getRangeExtent() methods (DG);
* 13-Jun-2002 : Modified range measurements to handle IntervalCategoryDataset (DG);
* 12-Jul-2002 : Method name change in DomainInfo interface (DG);
* 30-Jul-2002 : Added pie dataset summation method (DG);
* 01-Oct-2002 : Added a method for constructing an XYDataset from a Function2D instance (DG);
* 24-Oct-2002 : Amendments required following changes to the CategoryDataset interface (DG);
* 18-Nov-2002 : Changed CategoryDataset to TableDataset (DG);
* 04-Mar-2003 : Added isEmpty(XYDataset) method (DG);
* 05-Mar-2003 : Added a method for creating a CategoryDataset from a KeyedValues instance (DG);
* 15-May-2003 : Renamed isEmpty --> isEmptyOrNull (DG);
* 25-Jun-2003 : Added limitPieDataset methods (RA);
* 26-Jun-2003 : Modified getDomainExtent(...) method to accept null datasets (DG);
* 27-Jul-2003 : Added getStackedRangeExtent(TableXYDataset data) (RA);
* 18-Aug-2003 : getStackedRangeExtent(TableXYDataset data) now handles null values (RA);
* 02-Sep-2003 : Added method to check for null or empty PieDataset (DG);
*
*/
package org.jfree.data;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* A collection of useful static methods relating to datasets.
*
* @author David Gilbert
*/
public class DatasetUtilities {
/**
* To prevent instantiation.
*/
protected DatasetUtilities() {
}
/**
* Constructs an array of <code>Number</code> objects from an array of <code>double</code>
* primitives.
*
* @param data the data.
*
* @return an array of <code>Double</code>.
*/
public static Number[] createNumberArray(double[] data) {
Number[] result = new Number[data.length];
for (int i = 0; i < data.length; i++) {
result[i] = new Double(data[i]);
}
return result;
}
/**
* Constructs an array of arrays of <code>Number</code> objects from a corresponding
* structure containing <code>double</code> primitives.
*
* @param data the data.
*
* @return an array of <code>Double</code>.
*/
public static Number[][] createNumberArray2D(double[][] data) {
int l1 = data.length;
int l2 = data[0].length;
Number[][] result = new Number[l1][l2];
for (int i = 0; i < l1; i++) {
result[i] = createNumberArray(data[i]);
}
return result;
}
/**
* Returns the range of values in the domain for the dataset.
* <P>
* If the supplied dataset is <code>null</code>, the range returned is <code>null</code>.
*
* @param data the dataset (<code>null</code> permitted).
*
* @return The range of values (possibly <code>null</code>).
*/
public static Range getDomainExtent(Dataset data) {
// check parameters...
if (data == null) {
return null;
}
if ((data instanceof CategoryDataset) && !(data instanceof XYDataset)) {
throw new IllegalArgumentException("Datasets.getDomainExtent(...): "
+ "CategoryDataset does not have a numerical domain.");
}
// work out the minimum value...
if (data instanceof DomainInfo) {
DomainInfo info = (DomainInfo) data;
return info.getDomainRange();
}
// hasn't implemented DomainInfo, so iterate...
else if (data instanceof XYDataset) {
double minimum = Double.POSITIVE_INFINITY;
double maximum = Double.NEGATIVE_INFINITY;
XYDataset xyData = (XYDataset) data;
int seriesCount = xyData.getSeriesCount();
for (int series = 0; series < seriesCount; series++) {
int itemCount = xyData.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
Number lvalue = null;
Number uvalue = null;
if (data instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) data;
lvalue = intervalXYData.getStartXValue(series, item);
uvalue = intervalXYData.getEndXValue(series, item);
}
else {
lvalue = xyData.getXValue(series, item);
uvalue = lvalue;
}
if (lvalue != null) {
minimum = Math.min(minimum, lvalue.doubleValue());
}
if (uvalue != null) {
maximum = Math.max(maximum, uvalue.doubleValue());
}
}
}
if (minimum == Double.POSITIVE_INFINITY) {
return null;
}
else {
return new Range(minimum, maximum);
}
}
else {
return null; // unrecognised dataset...how should this be handled?
}
}
/**
* Returns the range of values in the range for the dataset. This method
* is the partner for the getDomainExtent method.
*
* @param data the dataset.
*
* @return the range of values in the range for the dataset.
*/
public static Range getRangeExtent(Dataset data) {
// check parameters...
if (data == null) {
return null;
}
// work out the minimum value...
if (data instanceof RangeInfo) {
RangeInfo info = (RangeInfo) data;
return info.getValueRange();
}
// hasn't implemented RangeInfo, so we'll have to iterate...
else if (data instanceof CategoryDataset) {
CategoryDataset tableData = (CategoryDataset) data;
double minimum = Double.POSITIVE_INFINITY;
double maximum = Double.NEGATIVE_INFINITY;
int rowCount = tableData.getRowCount();
int columnCount = tableData.getColumnCount();
for (int row = 0; row < rowCount; row++) {
for (int column = 0; column < columnCount; column++) {
Number lvalue = null;
Number uvalue = null;
if (data instanceof IntervalCategoryDataset) {
IntervalCategoryDataset icd = (IntervalCategoryDataset) data;
lvalue = icd.getStartValue(row, column);
uvalue = icd.getEndValue(row, column);
}
else {
lvalue = tableData.getValue(row, column);
uvalue = lvalue;
}
if (lvalue != null) {
minimum = Math.min(minimum, lvalue.doubleValue());
}
if (uvalue != null) {
maximum = Math.max(maximum, uvalue.doubleValue());
}
}
}
if (minimum == Double.POSITIVE_INFINITY) {
return null;
}
else {
return new Range(minimum, maximum);
}
}
else if (data instanceof XYDataset) {
// hasn't implemented RangeInfo, so we'll have to iterate...
XYDataset xyData = (XYDataset) data;
double minimum = Double.POSITIVE_INFINITY;
double maximum = Double.NEGATIVE_INFINITY;
int seriesCount = xyData.getSeriesCount();
for (int series = 0; series < seriesCount; series++) {
int itemCount = xyData.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
Number lvalue = null;
Number uvalue = null;
if (data instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) data;
lvalue = intervalXYData.getStartYValue(series, item);
uvalue = intervalXYData.getEndYValue(series, item);
}
else if (data instanceof HighLowDataset) {
HighLowDataset highLowData = (HighLowDataset) data;
lvalue = highLowData.getLowValue(series, item);
uvalue = highLowData.getHighValue(series, item);
}
else {
lvalue = xyData.getYValue(series, item);
uvalue = lvalue;
}
if (lvalue != null) {
minimum = Math.min(minimum, lvalue.doubleValue());
}
if (uvalue != null) {
maximum = Math.max(maximum, uvalue.doubleValue());
}
}
}
if (minimum == Double.POSITIVE_INFINITY) {
return null;
}
else {
return new Range(minimum, maximum);
}
}
else {
return null;
}
}
/**
* Returns the minimum domain value for the specified dataset.
* <P>
* This is easy if the dataset implements the DomainInfo interface (a good
* idea if there is an efficient way to determine the minimum value).
* Otherwise, it involves iterating over the entire data-set.
* <p>
* Returns null if all the data values in the dataset are null.
*
* @param data the dataset.
*
* @return the minimum domain value in the dataset (or null).
*/
public static Number getMinimumDomainValue(Dataset data) {
// check parameters...
if (data == null) {
throw new IllegalArgumentException(
"DatasetUtilities.getMinimumDomainValue: null dataset not allowed.");
}
if ((data instanceof CategoryDataset) && !(data instanceof XYDataset)) {
throw new IllegalArgumentException("DatasetUtilities.getMinimumDomainValue(...): "
+ "TableDataset does not have numerical domain.");
}
// work out the minimum value...
if (data instanceof DomainInfo) {
DomainInfo info = (DomainInfo) data;
return info.getMinimumDomainValue();
}
// hasn't implemented DomainInfo, so iterate...
else if (data instanceof XYDataset) {
double minimum = Double.POSITIVE_INFINITY;
XYDataset xyData = (XYDataset) data;
int seriesCount = xyData.getSeriesCount();
for (int series = 0; series < seriesCount; series++) {
int itemCount = xyData.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
Number value = null;
if (data instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) data;
value = intervalXYData.getStartXValue(series, item);
}
else {
value = xyData.getXValue(series, item);
}
if (value != null) {
minimum = Math.min(minimum, value.doubleValue());
}
}
}
if (minimum == Double.POSITIVE_INFINITY) {
return null;
}
else {
return new Double(minimum);
}
}
else {
return null; // unrecognised dataset...how should this be handled?
}
}
/**
* Returns the maximum domain value for the specified dataset.
* <P>
* This is easy if the dataset implements the DomainInfo interface (a good
* idea if there is an efficient way to determine the maximum value).
* Otherwise, it involves iterating over the entire data-set.
* <p>
* Returns null if all the data values in the dataset are null.
*
* @param data the dataset.
*
* @return the maximum domain value in the dataset (or null).
*/
public static Number getMaximumDomainValue(Dataset data) {
// check parameters...
if (data == null) {
throw new IllegalArgumentException(
"Datasets.getMaximumDomainValue: null dataset not allowed.");
}
if ((data instanceof CategoryDataset) && !(data instanceof XYDataset)) {
throw new IllegalArgumentException("Datasets.getMaximumDomainValue(...): "
+ "CategoryDataset does not have numerical domain.");
}
// work out the maximum value...
if (data instanceof DomainInfo) {
DomainInfo info = (DomainInfo) data;
return info.getMaximumDomainValue();
}
// hasn't implemented DomainInfo, so iterate...
else if (data instanceof XYDataset) {
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -