📄 datasetutilities.java
字号:
XYDataset xyData = (XYDataset) data;
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 value = null;
if (data instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) data;
value = intervalXYData.getEndXValue(series, item);
}
else {
value = xyData.getXValue(series, item);
}
if (value != null) {
maximum = Math.max(maximum, value.doubleValue());
}
}
}
if (maximum == Double.NEGATIVE_INFINITY) {
return null;
}
else {
return new Double(maximum);
}
}
else {
return null; // unrecognised dataset...how should this be handled?
}
}
/**
* Returns the minimum range value for the specified dataset.
* <P>
* This is easy if the dataset implements the RangeInfo 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 range value in the dataset (or null).
*/
public static Number getMinimumRangeValue(Dataset data) {
// check parameters...
if (data == null) {
throw new IllegalArgumentException(
"Datasets.getMinimumRangeValue: null dataset not allowed.");
}
// work out the minimum value...
if (data instanceof RangeInfo) {
RangeInfo info = (RangeInfo) data;
return info.getMinimumRangeValue();
}
// hasn't implemented RangeInfo, so we'll have to iterate...
else if (data instanceof CategoryDataset) {
CategoryDataset categoryData = (CategoryDataset) data;
double minimum = Double.POSITIVE_INFINITY;
int seriesCount = categoryData.getRowCount();
int itemCount = categoryData.getColumnCount();
for (int series = 0; series < seriesCount; series++) {
for (int item = 0; item < itemCount; item++) {
Number value = null;
if (data instanceof IntervalCategoryDataset) {
IntervalCategoryDataset icd = (IntervalCategoryDataset) data;
value = icd.getStartValue(series, item);
}
else {
value = categoryData.getValue(series, item);
}
if (value != null) {
minimum = Math.min(minimum, value.doubleValue());
}
}
}
if (minimum == Double.POSITIVE_INFINITY) {
return null;
}
else {
return new Double(minimum);
}
}
else if (data instanceof XYDataset) {
// hasn't implemented RangeInfo, so we'll have to iterate...
XYDataset xyData = (XYDataset) data;
double minimum = Double.POSITIVE_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 value = null;
if (data instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) data;
value = intervalXYData.getStartYValue(series, item);
}
else if (data instanceof HighLowDataset) {
HighLowDataset highLowData = (HighLowDataset) data;
value = highLowData.getLowValue(series, item);
}
else {
value = xyData.getYValue(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;
}
}
/**
* Returns the maximum range value for the specified dataset.
* <P>
* This is easy if the dataset implements the RangeInfo 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 are null.
*
* @param data the dataset.
*
* @return the maximum range value in the dataset (or null).
*/
public static Number getMaximumRangeValue(Dataset data) {
// check parameters...
if (data == null) {
throw new IllegalArgumentException(
"Datasets.getMinimumRangeValue: null dataset not allowed.");
}
// work out the minimum value...
if (data instanceof RangeInfo) {
RangeInfo info = (RangeInfo) data;
return info.getMaximumRangeValue();
}
// hasn't implemented RangeInfo, so we'll have to iterate...
else if (data instanceof CategoryDataset) {
CategoryDataset categoryData = (CategoryDataset) data;
double maximum = Double.NEGATIVE_INFINITY;
int seriesCount = categoryData.getColumnCount();
int itemCount = categoryData.getRowCount();
for (int series = 0; series < seriesCount; series++) {
for (int item = 0; item < itemCount; item++) {
Number value = null;
if (data instanceof IntervalCategoryDataset) {
IntervalCategoryDataset icd = (IntervalCategoryDataset) data;
value = icd.getEndValue(series, item);
}
else {
value = categoryData.getValue(series, item);
}
if (value != null) {
maximum = Math.max(maximum, value.doubleValue());
}
}
}
if (maximum == Double.NEGATIVE_INFINITY) {
return null;
}
else {
return new Double(maximum);
}
}
else if (data instanceof XYDataset) {
XYDataset xyData = (XYDataset) data;
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 value = null;
if (data instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) data;
value = intervalXYData.getEndYValue(series, item);
}
else if (data instanceof HighLowDataset) {
HighLowDataset highLowData = (HighLowDataset) data;
value = highLowData.getHighValue(series, item);
}
else {
value = xyData.getYValue(series, item);
}
if (value != null) {
maximum = Math.max(maximum, value.doubleValue());
}
}
}
if (maximum == Double.NEGATIVE_INFINITY) {
return null;
}
else {
return new Double(maximum);
}
}
else {
return null;
}
}
/**
* Creates a pie dataset from a table dataset by taking all the values
* for a single row.
*
* @param data the data.
* @param rowKey the row key.
*
* @return a pie dataset.
*/
public static PieDataset createPieDatasetForRow(CategoryDataset data, Comparable rowKey) {
int row = data.getRowIndex(rowKey);
return createPieDatasetForRow(data, row);
}
/**
* Creates a pie dataset from a table dataset by taking all the values
* for a single row.
*
* @param data the data.
* @param row the row (zero-based index).
*
* @return a pie dataset.
*/
public static PieDataset createPieDatasetForRow(CategoryDataset data, int row) {
DefaultPieDataset result = new DefaultPieDataset();
int columnCount = data.getColumnCount();
for (int current = 0; current < columnCount; current++) {
Comparable columnKey = data.getColumnKey(current);
result.setValue(columnKey, data.getValue(row, current));
}
return result;
}
/**
* Creates a pie dataset from a table dataset by taking all the values
* for a single column.
*
* @param data the data.
* @param columnKey the column key.
*
* @return a pie dataset.
*/
public static PieDataset createPieDatasetForColumn(CategoryDataset data,
Comparable columnKey) {
int column = data.getColumnIndex(columnKey);
return createPieDatasetForColumn(data, column);
}
/**
* Creates a pie dataset from a table dataset by taking all the values
* for a single column.
*
* @param data the data.
* @param column the column (zero-based index).
*
* @return a pie dataset.
*/
public static PieDataset createPieDatasetForColumn(CategoryDataset data, int column) {
DefaultPieDataset result = new DefaultPieDataset();
int rowCount = data.getRowCount();
for (int i = 0; i < rowCount; i++) {
Comparable rowKey = data.getRowKey(i);
result.setValue(rowKey, data.getValue(i, column));
}
return result;
}
/**
* Calculates the total of all the values in a {@link PieDataset}.
*
* @param data the dataset.
*
* @return the total.
*/
public static double getPieDatasetTotal(PieDataset data) {
// get a list of categories...
List categories = data.getKeys();
// compute the total value of the data series skipping over the negative values
double totalValue = 0;
Iterator iterator = categories.iterator();
while (iterator.hasNext()) {
Comparable current = (Comparable) iterator.next();
if (current != null) {
Number value = data.getValue(current);
double v = 0.0;
if (value != null) {
v = value.doubleValue();
}
if (v > 0) {
totalValue = totalValue + v;
}
}
}
return totalValue;
}
/**
* Returns the minimum and maximum values for the dataset's range (as in domain/range),
* assuming that the series in one category are stacked.
*
* @param data the dataset.
*
* @return the value range.
*/
public static Range getStackedRangeExtent(CategoryDataset data) {
Range result = null;
if (data != null) {
double minimum = 0.0;
double maximum = 0.0;
int categoryCount = data.getColumnCount();
for (int item = 0; item < categoryCount; item++) {
double positive = 0.0;
double negative = 0.0;
int seriesCount = data.getRowCount();
for (int series = 0; series < seriesCount; series++) {
Number number = data.getValue(series, item);
if (number != null) {
double value = number.doubleValue();
if (value > 0.0) {
positive = positive + value;
}
if (value < 0.0) {
negative = negative + value; // '+', remember value is negative
}
}
}
minimum = Math.min(minimum, negative);
maximum = Math.max(maximum, positive);
}
result = new Range(minimum, maximum);
}
return result;
}
/**
* Returns the minimum value in the dataset range, assuming that values in
* each category are "stacked".
*
* @param data the dataset.
*
* @return the minimum value.
*/
public static Number getMinimumStackedRangeValue(CategoryDataset data) {
Number result = null;
if (data != null) {
double minimum = 0.0;
int categoryCount = data.getRowCount();
for (int item = 0; item < categoryCount; item++) {
double total = 0.0;
int seriesCount = data.getColumnCount();
for (int series = 0; series < seriesCount; series++) {
Number number = data.getValue(series, item);
if (number != null) {
double value = number.doubleValue();
if (value < 0.0) {
total = total + value; // '+', remember value is negative
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -