/** * @param value number to convert * @param unit unit used in text * @return suggestions of the given number converted into metric units, sorted by naturalness * or null if conversion is not necessary / was not possible */ @Nullable protected List<Map.Entry<Unit, Double>> getMetricEquivalent(double value, @NotNull Unit unit) { LinkedList<Map.Entry<Unit, Double>> conversions = new LinkedList<>(); for (Unit metric : metricUnits) { if (unit.equals(metric)) { // don't convert to itself return null; } if (unit.isCompatible(metric)) { Double converted = unit.getConverterTo(metric).convert(value); conversions.add(new AbstractMap.SimpleImmutableEntry<>(metric, converted)); } } sortByNaturalness(conversions); if (conversions.size() == 0) { return null; } else { return conversions; } }
/** * Convert the given {@linkplain Date date} into a value in this axis unit. This method is the * converse of {@link #toDate}. * * @param time The value as a {@linkplain Date date}. * @return value A value in this axis unit. */ public double toValue(final Date time) { if (toMillis == null) { initializeConverter(); } return toMillis.inverse().convert(time.getTime() - origin); }
(float) tunit1.getSystemConverter() .concatenate(tunit2.getSystemConverter().inverse()) .convert(1.0f);
throw new IllegalArgumentException(e); if (converter.isIdentity()) { return new MeasurementRange<N>(type, this, targetUnits); Double minimum = converter.convert(getMinimum()); Double maximum = converter.convert(getMaximum()); if (minimum.compareTo(maximum) > 0) { final Double td = minimum;
/** * Concatenates this converter with another converter. The resulting converter is equivalent to first converting * by the specified converter (right converter), and then converting by this converter (left converter). */ @Override public UnitConverter concatenate(final UnitConverter converter) { ArgumentChecks.ensureNonNull("converter", converter); if (equals(converter.inverse())) { return LinearConverter.IDENTITY; } // Delegate to c1 and c2 because they may provide more intelligent 'concatenate' implementations. return c2.concatenate(c1.concatenate(converter)); }
/** On deserialization, returns an existing instance. */ protected Object readResolve() throws ObjectStreamException { UnitConverter candidate = INTEGER; for (int i = 0; i <= 3; i++) { switch (i) { case 0: break; // Do nothing since candidate is already set to INTEGER/ case 2: candidate = FRACTIONAL; break; default: candidate = candidate.inverse(); break; } if (equals(candidate)) { return candidate; } } return this; }
@Override public UnitConverter getSystemConverter() { return parentUnit.getSystemConverter().concatenate(converter); }
/** * Implementation of {@link #multiply(Unit)} and {@link #divide(Unit)} methods. */ private <T extends Quantity<T>> Unit<?> combine(final Unit<T> other, final boolean divide) { final Unit<T> step = other.getSystemUnit(); final Dimension dim = step.getDimension(); Unit<?> result = create(divide ? dimension.divide(dim) : dimension.multiply(dim)); if (step != other) { UnitConverter c = other.getConverterTo(step); if (!c.isLinear()) { throw new IllegalArgumentException(Errors.format(Errors.Keys.NonRatioUnit_1, other)); } if (divide) c = c.inverse(); result = result.transform(c); } return result; }
@Override public List<UnitConverter> getConversionSteps() { final List<UnitConverter> steps = new ArrayList<>(); List<? extends UnitConverter> leftCompound = left.getConversionSteps(); List<? extends UnitConverter> rightCompound = right.getConversionSteps(); steps.addAll(leftCompound); steps.addAll(rightCompound); return steps; }
if (!converter.isLinear()) { throw new IllegalArgumentException( Errors.format( targetUnit)); final double offset = converter.convert(0); final double scale = converter.convert(1) - offset; matrix.setElement(j, i, element * scale); matrix.setElement(j, sourceDim, matrix.getElement(j, sourceDim) + element * offset);
/** * Concatenates this converter with another converter. The resulting converter is equivalent to first converting * by the specified converter (right converter), and then converting by this converter (left converter). */ @Override public UnitConverter concatenate(final UnitConverter converter) { ArgumentChecks.ensureNonNull("converter", converter); if (equals(converter.inverse())) { return LinearConverter.IDENTITY; } // Delegate to c1 and c2 because they may provide more intelligent 'concatenate' implementations. return c2.concatenate(c1.concatenate(converter)); }
@Override public UnitConverter getSystemConverter() { return parentUnit.getSystemConverter().concatenate(converter); }
@Override public List<UnitConverter> getConversionSteps() { final List<UnitConverter> steps = new ArrayList<>(); List<? extends UnitConverter> leftCompound = left.getConversionSteps(); List<? extends UnitConverter> rightCompound = right.getConversionSteps(); steps.addAll(leftCompound); steps.addAll(rightCompound); return steps; }
List<String> reverseConverted = null; try { double unitConverted = unit.getConverterTo(convertedUnit).convert(value); double diff = Math.abs(unitConverted - convertedValueInText); if (diff > DELTA) {
/** Compares two values for equality. */ private static <Q extends Quantity<Q>> void checkConversion( final double expected, final Unit<Q> unitExpected, final double actual, final Unit<Q> unitActual) { UnitConverter converter = unitActual.getConverterTo(unitExpected); assertEquals(expected, converter.convert(actual), 1E-6); converter = converter.inverse(); assertEquals(actual, converter.convert(expected), 1E-6); }
/** * Returns the scale factor of the given converter if the conversion is linear, or NaN otherwise. */ static double scale(final UnitConverter converter) { if (converter != null && converter.isLinear() && converter.convert(0) == 0) { // Above check for converter(0) is a paranoiac check since // JSR-363 said that a "linear" converter has no offset. return converter.convert(1); } return Double.NaN; }