Example usage for org.jfree.chart.util Args nullNotPermitted

List of usage examples for org.jfree.chart.util Args nullNotPermitted

  1. HOME
  2. Java
  3. org.jfree
  4. org.jfree.chart.util.*
  5. Args
  6. nullNotPermitted

Introduction

In this page you can find the example usage for org.jfree.chart.util Args nullNotPermitted.

Prototype

public static void nullNotPermitted(Object param, String name)

Source Link

Document

Throws an IllegalArgumentException if the supplied param is null .

Usage

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the minimum range value for the specified dataset.  This is
 * easy if the dataset implements the {@link 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.  Returns
 * {@code null} if all the data values in the dataset are
 * {@code null}.//from  ww  w . j  a  va2 s  .  c o  m
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The minimum value (possibly {@code null}).
 */
public static Number findMinimumRangeValue(XYDataset dataset) {
    Args.nullNotPermitted(dataset, "dataset");

    // work out the minimum value...
    if (dataset instanceof RangeInfo) {
        RangeInfo info = (RangeInfo) dataset;
        return new Double(info.getRangeLowerBound(true));
    }

    // hasn't implemented RangeInfo, so we'll have to iterate...
    else {
        double minimum = Double.POSITIVE_INFINITY;
        int seriesCount = dataset.getSeriesCount();
        for (int series = 0; series < seriesCount; series++) {
            int itemCount = dataset.getItemCount(series);
            for (int item = 0; item < itemCount; item++) {

                double value;
                if (dataset instanceof IntervalXYDataset) {
                    IntervalXYDataset intervalXYData = (IntervalXYDataset) dataset;
                    value = intervalXYData.getStartYValue(series, item);
                } else if (dataset instanceof OHLCDataset) {
                    OHLCDataset highLowData = (OHLCDataset) dataset;
                    value = highLowData.getLowValue(series, item);
                } else {
                    value = dataset.getYValue(series, item);
                }
                if (!Double.isNaN(value)) {
                    minimum = Math.min(minimum, value);
                }

            }
        }
        if (minimum == Double.POSITIVE_INFINITY) {
            return null;
        } else {
            return new Double(minimum);
        }

    }

}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the maximum range value for the specified dataset.  This is easy
 * if the dataset implements the {@link 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.  Returns
 * {@code null} if all the data values are {@code null}.
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The maximum value (possibly {@code null}).
 *//*w  w  w  .jav a2s  .  c  om*/
public static Number findMaximumRangeValue(CategoryDataset dataset) {

    Args.nullNotPermitted(dataset, "dataset");

    // work out the minimum value...
    if (dataset instanceof RangeInfo) {
        RangeInfo info = (RangeInfo) dataset;
        return new Double(info.getRangeUpperBound(true));
    }

    // hasn't implemented RangeInfo, so we'll have to iterate...
    else {

        double maximum = Double.NEGATIVE_INFINITY;
        int seriesCount = dataset.getRowCount();
        int itemCount = dataset.getColumnCount();
        for (int series = 0; series < seriesCount; series++) {
            for (int item = 0; item < itemCount; item++) {
                Number value;
                if (dataset instanceof IntervalCategoryDataset) {
                    IntervalCategoryDataset icd = (IntervalCategoryDataset) dataset;
                    value = icd.getEndValue(series, item);
                } else {
                    value = dataset.getValue(series, item);
                }
                if (value != null) {
                    maximum = Math.max(maximum, value.doubleValue());
                }
            }
        }
        if (maximum == Double.NEGATIVE_INFINITY) {
            return null;
        } else {
            return new Double(maximum);
        }

    }

}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the maximum range value for the specified dataset.  This is
 * easy if the dataset implements the {@link 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.  Returns
 * {@code null} if all the data values are {@code null}.
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The maximum value (possibly {@code null}).
 *///w ww.j  ava  2s .  com
public static Number findMaximumRangeValue(XYDataset dataset) {

    Args.nullNotPermitted(dataset, "dataset");

    // work out the minimum value...
    if (dataset instanceof RangeInfo) {
        RangeInfo info = (RangeInfo) dataset;
        return new Double(info.getRangeUpperBound(true));
    }

    // hasn't implemented RangeInfo, so we'll have to iterate...
    else {

        double maximum = Double.NEGATIVE_INFINITY;
        int seriesCount = dataset.getSeriesCount();
        for (int series = 0; series < seriesCount; series++) {
            int itemCount = dataset.getItemCount(series);
            for (int item = 0; item < itemCount; item++) {
                double value;
                if (dataset instanceof IntervalXYDataset) {
                    IntervalXYDataset intervalXYData = (IntervalXYDataset) dataset;
                    value = intervalXYData.getEndYValue(series, item);
                } else if (dataset instanceof OHLCDataset) {
                    OHLCDataset highLowData = (OHLCDataset) dataset;
                    value = highLowData.getHighValue(series, item);
                } else {
                    value = dataset.getYValue(series, item);
                }
                if (!Double.isNaN(value)) {
                    maximum = Math.max(maximum, value);
                }
            }
        }
        if (maximum == Double.NEGATIVE_INFINITY) {
            return null;
        } else {
            return new Double(maximum);
        }

    }

}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the minimum and maximum values for the dataset's range
 * (y-values), assuming that the series in one category are stacked.
 *
 * @param dataset  the dataset ({@code null} not permitted).
 * @param base  the base value for the bars.
 *
 * @return The range ({@code null} if the dataset contains no values).
 *//*from  www .  jav  a 2s. c  om*/
public static Range findStackedRangeBounds(CategoryDataset dataset, double base) {
    Args.nullNotPermitted(dataset, "dataset");
    Range result = null;
    double minimum = Double.POSITIVE_INFINITY;
    double maximum = Double.NEGATIVE_INFINITY;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double positive = base;
        double negative = base;
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.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);
    }
    if (minimum <= maximum) {
        result = new Range(minimum, maximum);
    }
    return result;

}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the minimum and maximum values for the dataset's range
 * (y-values), assuming that the series in one category are stacked.
 *
 * @param dataset  the dataset./*from w w  w  . ja va2  s .  c o m*/
 * @param map  a structure that maps series to groups.
 *
 * @return The value range ({@code null} if the dataset contains no
 *         values).
 */
public static Range findStackedRangeBounds(CategoryDataset dataset, KeyToGroupMap map) {
    Args.nullNotPermitted(dataset, "dataset");
    boolean hasValidData = false;
    Range result = null;

    // create an array holding the group indices for each series...
    int[] groupIndex = new int[dataset.getRowCount()];
    for (int i = 0; i < dataset.getRowCount(); i++) {
        groupIndex[i] = map.getGroupIndex(map.getGroup(dataset.getRowKey(i)));
    }

    // minimum and maximum for each group...
    int groupCount = map.getGroupCount();
    double[] minimum = new double[groupCount];
    double[] maximum = new double[groupCount];

    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double[] positive = new double[groupCount];
        double[] negative = new double[groupCount];
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                hasValidData = true;
                double value = number.doubleValue();
                if (value > 0.0) {
                    positive[groupIndex[series]] = positive[groupIndex[series]] + value;
                }
                if (value < 0.0) {
                    negative[groupIndex[series]] = negative[groupIndex[series]] + value;
                    // '+', remember value is negative
                }
            }
        }
        for (int g = 0; g < groupCount; g++) {
            minimum[g] = Math.min(minimum[g], negative[g]);
            maximum[g] = Math.max(maximum[g], positive[g]);
        }
    }
    if (hasValidData) {
        for (int j = 0; j < groupCount; j++) {
            result = Range.combine(result, new Range(minimum[j], maximum[j]));
        }
    }
    return result;
}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the minimum value in the dataset range, assuming that values in
 * each category are "stacked".//ww w. j  a  va2 s . c o m
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The minimum value.
 *
 * @see #findMaximumStackedRangeValue(CategoryDataset)
 */
public static Number findMinimumStackedRangeValue(CategoryDataset dataset) {
    Args.nullNotPermitted(dataset, "dataset");
    Number result = null;
    boolean hasValidData = false;
    double minimum = 0.0;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double total = 0.0;
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                hasValidData = true;
                double value = number.doubleValue();
                if (value < 0.0) {
                    total = total + value;
                    // '+', remember value is negative
                }
            }
        }
        minimum = Math.min(minimum, total);
    }
    if (hasValidData) {
        result = new Double(minimum);
    }
    return result;
}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the maximum value in the dataset range, assuming that values in
 * each category are "stacked".//from  ww w.  j av  a2s .  c o  m
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The maximum value (possibly {@code null}).
 *
 * @see #findMinimumStackedRangeValue(CategoryDataset)
 */
public static Number findMaximumStackedRangeValue(CategoryDataset dataset) {
    Args.nullNotPermitted(dataset, "dataset");
    Number result = null;
    boolean hasValidData = false;
    double maximum = 0.0;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double total = 0.0;
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                hasValidData = true;
                double value = number.doubleValue();
                if (value > 0.0) {
                    total = total + value;
                }
            }
        }
        maximum = Math.max(maximum, total);
    }
    if (hasValidData) {
        result = new Double(maximum);
    }
    return result;
}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the minimum and maximum values for the dataset's range,
 * assuming that the series are stacked, using the specified base value.
 *
 * @param dataset  the dataset ({@code null} not permitted).
 * @param base  the base value./*from   w w w . j  a  v  a  2s. co  m*/
 *
 * @return The range ({@code null} if the dataset contains no values).
 */
public static Range findStackedRangeBounds(TableXYDataset dataset, double base) {
    Args.nullNotPermitted(dataset, "dataset");
    double minimum = base;
    double maximum = base;
    for (int itemNo = 0; itemNo < dataset.getItemCount(); itemNo++) {
        double positive = base;
        double negative = base;
        int seriesCount = dataset.getSeriesCount();
        for (int seriesNo = 0; seriesNo < seriesCount; seriesNo++) {
            double y = dataset.getYValue(seriesNo, itemNo);
            if (!Double.isNaN(y)) {
                if (y > 0.0) {
                    positive += y;
                } else {
                    negative += y;
                }
            }
        }
        if (positive > maximum) {
            maximum = positive;
        }
        if (negative < minimum) {
            minimum = negative;
        }
    }
    if (minimum <= maximum) {
        return new Range(minimum, maximum);
    } else {
        return null;
    }
}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Calculates the range of values for a dataset where each item is the
 * running total of the items for the current series.
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The range.//  ww  w.j a va 2s .c  o m
 *
 * @see #findRangeBounds(CategoryDataset)
 */
public static Range findCumulativeRangeBounds(CategoryDataset dataset) {
    Args.nullNotPermitted(dataset, "dataset");
    boolean allItemsNull = true; // we'll set this to false if there is at
                                 // least one non-null data item...
    double minimum = 0.0;
    double maximum = 0.0;
    for (int row = 0; row < dataset.getRowCount(); row++) {
        double runningTotal = 0.0;
        for (int column = 0; column <= dataset.getColumnCount() - 1; column++) {
            Number n = dataset.getValue(row, column);
            if (n != null) {
                allItemsNull = false;
                double value = n.doubleValue();
                if (!Double.isNaN(value)) {
                    runningTotal = runningTotal + value;
                    minimum = Math.min(minimum, runningTotal);
                    maximum = Math.max(maximum, runningTotal);
                }
            }
        }
    }
    if (!allItemsNull) {
        return new Range(minimum, maximum);
    } else {
        return null;
    }
}

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Finds the indices of the the items in the dataset that span the 
 * specified x-value.  There are three cases for the return value:
 * <ul>//from   www  . j  a  va  2 s  .  c o  m
 * <li>there is an exact match for the x-value at index i 
 * (returns {@code int[] {i, i}});</li>
 * <li>the x-value falls between two (adjacent) items at index i and i+1 
 * (returns {@code int[] {i, i+1}});</li>
 * <li>the x-value falls outside the domain bounds, in which case the 
 *    method returns {@code int[] {-1, -1}}.</li>
 * </ul>
 * @param dataset  the dataset ({@code null} not permitted).
 * @param series  the series index.
 * @param x  the x-value.
 *
 * @return The indices of the two items that span the x-value.
 *
 * @since 1.0.16
 * 
 * @see #findYValue(org.jfree.data.xy.XYDataset, int, double) 
 */
public static int[] findItemIndicesForX(XYDataset dataset, int series, double x) {
    Args.nullNotPermitted(dataset, "dataset");
    int itemCount = dataset.getItemCount(series);
    if (itemCount == 0) {
        return new int[] { -1, -1 };
    }
    if (itemCount == 1) {
        if (x == dataset.getXValue(series, 0)) {
            return new int[] { 0, 0 };
        } else {
            return new int[] { -1, -1 };
        }
    }
    if (dataset.getDomainOrder() == DomainOrder.ASCENDING) {
        int low = 0;
        int high = itemCount - 1;
        double lowValue = dataset.getXValue(series, low);
        if (lowValue > x) {
            return new int[] { -1, -1 };
        }
        if (lowValue == x) {
            return new int[] { low, low };
        }
        double highValue = dataset.getXValue(series, high);
        if (highValue < x) {
            return new int[] { -1, -1 };
        }
        if (highValue == x) {
            return new int[] { high, high };
        }
        int mid = (low + high) / 2;
        while (high - low > 1) {
            double midV = dataset.getXValue(series, mid);
            if (x == midV) {
                return new int[] { mid, mid };
            }
            if (midV < x) {
                low = mid;
            } else {
                high = mid;
            }
            mid = (low + high) / 2;
        }
        return new int[] { low, high };
    } else if (dataset.getDomainOrder() == DomainOrder.DESCENDING) {
        int high = 0;
        int low = itemCount - 1;
        double lowValue = dataset.getXValue(series, low);
        if (lowValue > x) {
            return new int[] { -1, -1 };
        }
        double highValue = dataset.getXValue(series, high);
        if (highValue < x) {
            return new int[] { -1, -1 };
        }
        int mid = (low + high) / 2;
        while (high - low > 1) {
            double midV = dataset.getXValue(series, mid);
            if (x == midV) {
                return new int[] { mid, mid };
            }
            if (midV < x) {
                low = mid;
            } else {
                high = mid;
            }
            mid = (low + high) / 2;
        }
        return new int[] { low, high };
    } else {
        // we don't know anything about the ordering of the x-values,
        // so we iterate until we find the first crossing of x (if any)
        // we know there are at least 2 items in the series at this point
        double prev = dataset.getXValue(series, 0);
        if (x == prev) {
            return new int[] { 0, 0 }; // exact match on first item
        }
        for (int i = 1; i < itemCount; i++) {
            double next = dataset.getXValue(series, i);
            if (x == next) {
                return new int[] { i, i }; // exact match
            }
            if ((x > prev && x < next) || (x < prev && x > next)) {
                return new int[] { i - 1, i }; // spanning match
            }
        }
        return new int[] { -1, -1 }; // no crossing of x
    }
}