/** * Returns the inverse of this transform. */ @Override public synchronized MathTransform1D inverse() { if (inverse == null) { inverse = LogarithmicTransform1D.create(this); // Above method will set LogarithmicTransform1D.inverse = this. } return inverse; }
/** * Returns the inverse of this transform. */ @Override public synchronized MathTransform1D inverse() { if (inverse == null) { inverse = LogarithmicTransform1D.create(this); // Above method will set LogarithmicTransform1D.inverse = this. } return inverse; }
/** * Implementation of {@link #testSingle()} and {@link #testSingleWithOffset()} for the given base. */ private void testSingle(final double base, final double offset, final Class<? extends MathTransform1D> expectedType) throws TransformException { transform = LogarithmicTransform1D.create(base, offset); run(expectedType, base, offset, false, false); }
/** * Implementation of {@link #testAffinePreConcatenation()} for the given base. */ private void testAffinePreConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(LinearTransform1D.create(C1, C0), LogarithmicTransform1D.create(base, OFFSET)); run(ConcatenatedTransformDirect1D.class, base, OFFSET, true, false); }
/** * Implementation of {@link #testAffinePostConcatenation()} for the given base. */ private void testAffinePostConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(LogarithmicTransform1D.create(base, OFFSET), LinearTransform1D.create(C1, C0)); run(ConcatenatedTransformDirect1D.class, base, OFFSET, false, true); }
/** * Implementation of {@link #testAffineConcatenations()} for the given base. */ private void testAffineConcatenations(final double base) throws TransformException { final MathTransform1D linear = LinearTransform1D.create(C1, C0); transform = MathTransforms.concatenate(linear, LogarithmicTransform1D.create(base, OFFSET), linear); run(ConcatenatedTransformDirect1D.class, base, OFFSET, true, true); }
/** * Implementation of {@link #testAffinePreConcatenation()} for the given base. */ private void testAffinePreConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(LinearTransform1D.create(C1, C0), ExponentialTransform1D.create(base, SCALE)); run(ExponentialTransform1D.class, base, SCALE, true, false); /* * Find back the original linear coefficients as documented in the ExponentialTransform1D class javadoc. */ final double offset = -log(SCALE) / log(base); final MathTransform1D log = LogarithmicTransform1D.create(base, offset); transform = (LinearTransform1D) MathTransforms.concatenate(transform, log); assertEquals("C1", C1, ((LinearTransform1D) transform).scale, EPS); assertEquals("C0", C0, ((LinearTransform1D) transform).offset, EPS); }
/** * Tests the concatenation of a logarithmic operation with the exponential one. * * @throws TransformException should never happen. */ @Test @DependsOnMethod("testSingleWithOffset") public void testLogarithmicConcatenation() throws TransformException { transform = MathTransforms.concatenate( LogarithmicTransform1D.create(8, C0), ExponentialTransform1D.create(10, ExponentialTransform1DTest.SCALE)); validate(); final double lnBase = log(8); final double[] values = generateRandomCoordinates(CoordinateDomain.RANGE_10, 0); final double[] expected = new double[values.length]; for (int i=0; i<values.length; i++) { final double value = abs(values[i]) + 0.001; // Makes the values valid for logarithms. values[i] = value; expected[i] = ExponentialTransform1DTest.SCALE * pow(10, log(value) / lnBase + C0); } verifyTransform(values, expected); } }