/** * Returns the {@linkplain #getMinValue() minimum value} as a {@code double}. * If this range is unbounded, then {@link Double#NEGATIVE_INFINITY} is returned. * * @return the minimum value. */ @SuppressWarnings("unchecked") public double getMinDouble() { final Number value = getMinValue(); return (value != null) ? value.doubleValue() : Double.NEGATIVE_INFINITY; }
/** * Returns the {@linkplain #getMinValue() minimum value} as a {@code double}. * If this range is unbounded, then {@link Double#NEGATIVE_INFINITY} is returned. * * @return the minimum value. */ @SuppressWarnings("unchecked") public double getMinDouble() { final Number value = getMinValue(); return (value != null) ? value.doubleValue() : Double.NEGATIVE_INFINITY; }
/** * Returns an object to format for representing the range of values for display purpose only. * It may be either the {@link NumberRange}, a single {@link Number} or a {@link String} with * a text like "NaN #0". */ final Object getRangeLabel() { if (Double.isNaN(minimum)) { return "NaN #" + MathFunctions.toNanOrdinal((float) minimum); } else if (minimum == maximum) { return range.getMinValue(); } else { return range; } }
/** * Creates a new sample dimension for values that are already converted to real values. * This transfer function is set to identity, which implies that this constructor should * be invoked only for sample dimensions having at least one quantitative category. * * @param original the original sample dimension for packed values. * @param bc category of the background value in original sample dimension, or {@code null}. */ private SampleDimension(final SampleDimension original, Category bc) { converse = original; name = original.name; categories = original.categories.converse; transferFunction = Category.identity(); assert hasQuantitative(); if (bc == null) { background = null; } else { bc = bc.converse; final NumberRange<?> range = bc.range; if (range != null) { background = range.getMinValue(); } else { background = (float) bc.minimum; } } }
/** * Adds a qualitative category and marks that category as the background value. * This is the value to be returned by {@link SampleDimension#getBackground()}. * If this method is invoked more than once, then the last specified value prevails * (previous values become ordinary qualitative categories). * * @param name the category name as a {@link String} or {@link InternationalString} object, * or {@code null} for a default "fill value" name. * @param sample the background value. * @return {@code this}, for method call chaining. */ public Builder setBackground(CharSequence name, Number sample) { ArgumentChecks.ensureNonNull("sample", sample); if (name == null) { name = Vocabulary.formatInternational(Vocabulary.Keys.FillValue); } final NumberRange<?> samples = range(sample.getClass(), sample, sample); background = samples.getMinValue(); toNaN.background = background.doubleValue(); categories.add(new Category(name, samples, null, null, toNaN)); return this; }
for (int i=0; i<count; i++) { final NumberRange<?> range = ranges[i]; final Number minimum = range.getMinValue(); final Number maximum = range.getMaxValue(); if (range.isMinIncluded()) noDataValues.add(Numbers.cast(minimum, widestClass));
/** * Creates a range initialized to the given value. */ private MultiplicityRange(final NumberRange<Integer> range) { if (range != null) { lower = range.getMinValue(); if (lower == null) { lower = NilReason.UNKNOWN.createNilObject(Integer.class); } else if (!range.isMinIncluded()) { lower = Math.incrementExact(lower); } upper = new UnlimitedInteger(range.getMaxValue(), range.isMaxIncluded()); } else { lower = 0; upper = new UnlimitedInteger(); // Initialized to missing value. } }
final Number min = range.getMinValue(); final Number max = range.getMaxValue(); final boolean isInteger = (min.doubleValue() >= Long.MIN_VALUE &&
final Number min = range.getMinValue(); final Number max = range.getMaxValue(); final boolean isInteger = (min.doubleValue() >= Long.MIN_VALUE &&
/** * Tests the sample values range and converged values range after construction of a list of categories. */ @Test public void testRanges() { final CategoryList list = new CategoryList(categories(), null); assertSorted(list); assertTrue ("isMinIncluded", list.range.isMinIncluded()); assertFalse ("isMaxIncluded", list.range.isMaxIncluded()); assertFalse ("converse.isMinIncluded", list.converse.range.isMinIncluded()); // Because computed from maxValue before conversion. assertFalse ("converse.isMaxIncluded", list.converse.range.isMaxIncluded()); assertEquals("minValue", 0, ((Number) list.range .getMinValue()).doubleValue(), STRICT); assertEquals("maxValue", 120, ((Number) list.range .getMaxValue()).doubleValue(), STRICT); assertEquals("converse.minValue", -117, ((Number) list.converse.range.getMinValue()).doubleValue(), STRICT); assertEquals("converse.maxValue", 15, ((Number) list.converse.range.getMaxValue()).doubleValue(), STRICT); assertEquals("converse.minValue", -117, list.converse.range.getMinDouble(false), STRICT); assertEquals("converse.maxValue", 15, list.converse.range.getMaxDouble(false), STRICT); assertEquals("converse.minValue", -116, list.converse.range.getMinDouble(true), CategoryTest.EPS); assertEquals("converse.maxValue", 14.9, list.converse.range.getMaxDouble(true), CategoryTest.EPS); }
/** * Creates a category for data that are already real values. */ @Test public void testConvertedCategory() { final Random random = TestUtilities.createRandomNumberGenerator(); for (int pass=0; pass<3; pass++) { final double lower = random.nextDouble() * 5; final double upper = random.nextDouble() * 10 + lower; final Category category = new Category("Random", NumberRange.create(lower, true, upper, true), (MathTransform1D) MathTransforms.identity(1), null, null); assertSame ("converse", category, category.converse); assertEquals ("name", "Random", String.valueOf(category.name)); assertEquals ("name", "Random", String.valueOf(category.getName())); assertEquals ("minimum", lower, category.minimum, STRICT); assertEquals ("maximum", upper, category.maximum, STRICT); assertBoundEquals("range.minValue", lower, category.range.getMinValue()); assertBoundEquals("range.maxValue", upper, category.range.getMaxValue()); assertSame ("sampleRange", category.range, category.getSampleRange()); assertSame ("measurementRange", category.range, category.getMeasurementRange().get()); assertSame ("transferFunction", category.toConverse, category.getTransferFunction().get()); assertTrue ("toConverse.isIdentity", category.toConverse.isIdentity()); assertTrue ("isQuantitative", category.isQuantitative()); } }
assertEquals("minimum", -2f, range.getMinValue()); assertEquals("maximum", 30f, range.getMaxValue());
/** * Tests a category with a NaN value. */ @Test public void testCategoryNaN() { final Category category = new Category("NaN", new NumberRange<>(Float.class, Float.NaN, true, Float.NaN, true), null, null, null); final NumberRange<?> range = category.getSampleRange(); assertSame ("converse", category, category.converse); assertEquals("name", "NaN", String.valueOf(category.name)); assertEquals("name", "NaN", String.valueOf(category.getName())); assertEquals("minimum", Double.NaN, category.minimum, STRICT); assertEquals("maximum", Double.NaN, category.maximum, STRICT); assertNull ("sampleRange", category.range); assertEquals("range.minValue", Float.NaN, range.getMinValue()); assertEquals("range.maxValue", Float.NaN, range.getMaxValue()); assertFalse ("measurementRange", category.getMeasurementRange().isPresent()); assertFalse ("transferFunction", category.getTransferFunction().isPresent()); assertTrue ("toConverse.isIdentity", category.toConverse.isIdentity()); assertFalse ("isQuantitative", category.isQuantitative()); } }
assertEquals ("minimum", lower*scale+offset, converse.minimum, EPS); assertEquals ("maximum", upper*scale+offset, converse.maximum, EPS); assertBoundEquals("range.minValue", lower, category.range.getMinValue()); assertBoundEquals("range.maxValue", upper, category.range.getMaxValue()); assertBoundEquals("range.minValue", converse.minimum, converse.range.getMinValue()); assertBoundEquals("range.maxValue", converse.maximum, converse.range.getMaxValue()); assertSame ("sampleRange", category.range, category.getSampleRange());
assertEquals ("minimum", sample, category.minimum, STRICT); assertEquals ("maximum", sample, category.maximum, STRICT); assertBoundEquals("range.minValue", sample, category.range.getMinValue()); assertBoundEquals("range.maxValue", sample, category.range.getMaxValue()); assertSame ("sampleRange", category.range, category.getSampleRange());