sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1601600 - in /sis/branches/JDK8/core/sis-referencing/src: main/java/org/apache/sis/referencing/operation/transform/ test/java/org/apache/sis/referencing/operation/transform/ test/java/org/apache/sis/test/suite/
Date Tue, 10 Jun 2014 10:36:57 GMT
Author: desruisseaux
Date: Tue Jun 10 10:36:56 2014
New Revision: 1601600

URL: http://svn.apache.org/r1601600
Log:
Initial port of LogarithmicTransform1D and ExponentialTransform1D.
Will need revision - we may simplify LogarithmicTransform1D by fixing the base to 10 or e,
which are the majority of cases. Other cases can be handled by concatenating a LinearTransform1D.

Added:
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java   (with props)
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java   (with props)
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java   (with props)
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java   (with props)
Modified:
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PowerTransform1D.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PassThroughTransformTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java?rev=1601600&r1=1601599&r2=1601600&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -818,7 +818,7 @@ public abstract class AbstractMathTransf
     public final boolean equals(final Object object) {
         final boolean eq = equals(object, ComparisonMode.STRICT);
         // If objects are equal, then they must have the same hash code value.
-        assert !eq || hashCode() == object.hashCode() : this;
+        assert !eq || computeHashCode() == ((AbstractMathTransform) object).computeHashCode() : this;
         return eq;
     }
 

Added: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java?rev=1601600&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java (added)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -0,0 +1,307 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.referencing.operation.transform;
+
+import java.io.Serializable;
+import org.opengis.referencing.operation.MathTransform;
+import org.opengis.referencing.operation.MathTransform1D;
+import org.apache.sis.internal.util.Numerics;
+import org.apache.sis.util.ComparisonMode;
+
+
+/**
+ * A one dimensional exponential transform.
+ * Input values <var>x</var> are converted into output values <var>y</var> using the following equation:
+ *
+ * <blockquote><var>y</var>  =  {@linkplain #scale} ⋅ {@linkplain #base}<sup><var>x</var></sup></blockquote>
+ *
+ * <div class="note"><b>Tip:</b> if a linear transform is applied before this exponential transform,
+ * then the equation can be rewritten as:
+ *
+ * <blockquote><code>scale</code> ⋅ <code>base</code><sup><var>a</var> + <var>b</var>⋅<var>x</var></sup>
+ *  =  <code>scale</code> ⋅ <code>base</code><sup><var>a</var></sup> ⋅
+ * (<code>base</code><sup><var>b</var></sup>)<sup><var>x</var></sup></blockquote>
+ *
+ * It is possible to find back the coefficients of the original linear transform by
+ * pre-concatenating a logarithmic transform before the exponential one, as below:
+ *
+ * {@preformat java
+ *   LinearTransform1D linear = (LinearTransform1D) ConcatenatedTransform.create(exponentialTransform,
+ *           LogarithmicTransform1D.create(base, -Math.log(scale) / Math.log(base)));
+ * }
+ * </div>
+ *
+ * {@section Serialization}
+ * Serialized instances of this class are not guaranteed to be compatible with future SIS versions.
+ * Serialization should be used only for short term storage or RMI between applications running the
+ * same SIS version.
+ *
+ * @author  Martin Desruisseaux (IRD, Geomatys)
+ * @since   0.5 (derived from geotk-2.0)
+ * @version 0.5
+ * @module
+ */
+final class ExponentialTransform1D extends AbstractMathTransform1D implements Serializable {
+    /**
+     * Serial number for inter-operability with different versions.
+     */
+    private static final long serialVersionUID = 5331178990358868947L;
+
+    /**
+     * The base to be raised to a power.
+     */
+    protected final double base;
+
+    /**
+     * Natural logarithm of {@link #base}.
+     */
+    final double lnBase;
+
+    /**
+     * The scale value to be multiplied.
+     *
+     * <div class="note">The scale could be handled by a concatenation with {@link LinearTransform1D} instead than
+     * an explicit field in this class. However the <var>scale</var> ⋅ <var>base</var><sup><var>x</var></sup> formula
+     * is extensively used as a <cite>transfer function</cite> in grid coverages. Consequently we keep this explicit
+     * field for performance reasons.</div>
+     */
+    protected final double scale;
+
+    /**
+     * The inverse of this transform. Created only when first needed. Serialized in order to avoid
+     * rounding error if this transform is actually the one which was created from the inverse.
+     */
+    private MathTransform1D inverse;
+
+    /**
+     * Constructs a new exponential transform which is the
+     * inverse of the supplied logarithmic transform.
+     */
+    ExponentialTransform1D(final LogarithmicTransform1D inverse) {
+        this.base     = inverse.base;
+        this.lnBase   = inverse.lnBase;
+        this.scale    = Math.pow(base, -inverse.offset);
+        this.inverse  = inverse;
+    }
+
+    /**
+     * Constructs a new exponential transform. This constructor is provided for subclasses only.
+     * Instances should be created using the {@linkplain #create(double, double) factory method},
+     * which may returns optimized implementations for some particular argument values.
+     *
+     * @param base   The base to be raised to a power.
+     * @param scale  The scale value to be multiplied.
+     */
+    protected ExponentialTransform1D(final double base, final double scale) {
+        this.base   = base;
+        this.scale  = scale;
+        this.lnBase = Math.log(base);
+    }
+
+    /**
+     * Constructs a new exponential transform which include the given scale factor applied
+     * after the exponentiation.
+     *
+     * @param  base   The base to be raised to a power.
+     * @param  scale  The scale value to be multiplied.
+     * @return The math transform.
+     */
+    public static MathTransform1D create(final double base, final double scale) {
+        if (base == 0 || scale == 0) {
+            return LinearTransform1D.create(0, 0);
+        }
+        if (base == 1) {
+            return LinearTransform1D.create(scale, 0);
+        }
+        return new ExponentialTransform1D(base, scale);
+    }
+
+    /**
+     * Creates the inverse transform of this object.
+     */
+    @Override
+    public synchronized MathTransform1D inverse() {
+        if (inverse == null) {
+            inverse = LogarithmicTransform1D.create(this);
+            // Above method will set LogarithmicTransform1D.inverse = this.
+        }
+        return inverse;
+    }
+
+    /**
+     * Gets the derivative of this function at a value.
+     */
+    @Override
+    public double derivative(final double value) {
+        return lnBase * transform(value);
+    }
+
+    /**
+     * Transforms the specified value.
+     */
+    @Override
+    public double transform(final double value) {
+        return scale * Math.pow(base, value);
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final double[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
+        if (srcPts != dstPts || srcOff >= dstOff) {
+            while (--numPts >= 0) {
+                dstPts[dstOff++] = scale * Math.pow(base, srcPts[srcOff++]);
+            }
+        } else {
+            srcOff += numPts;
+            dstOff += numPts;
+            while (--numPts >= 0) {
+                dstPts[--dstOff] = scale * Math.pow(base, srcPts[--srcOff]);
+            }
+        }
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final float[] srcPts, int srcOff, final float[] dstPts, int dstOff, int numPts) {
+        if (srcPts != dstPts || srcOff >= dstOff) {
+            while (--numPts >= 0) {
+                dstPts[dstOff++] = (float) (scale * Math.pow(base, srcPts[srcOff++]));
+            }
+        } else {
+            srcOff += numPts;
+            dstOff += numPts;
+            while (--numPts >= 0) {
+                dstPts[--dstOff] = (float) (scale * Math.pow(base, srcPts[--srcOff]));
+            }
+        }
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final double[] srcPts, int srcOff, final float[] dstPts, int dstOff, int numPts) {
+        while (--numPts >= 0) {
+            dstPts[dstOff++] = (float) (scale * Math.pow(base, srcPts[srcOff++]));
+        }
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final float[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
+        while (--numPts >= 0) {
+            dstPts[dstOff++] = scale * Math.pow(base, srcPts[srcOff++]);
+        }
+    }
+
+    /**
+     * Concatenates in an optimized way a {@link MathTransform} {@code other} to this
+     * {@code MathTransform}. This implementation can optimize some concatenation with
+     * {@link LinearTransform1D} and {@link LogarithmicTransform1D}.
+     *
+     * @param  other The math transform to apply.
+     * @param  applyOtherFirst {@code true} if the transformation order is {@code other}
+     *         followed by {@code this}, or {@code false} if the transformation order is
+     *         {@code this} followed by {@code other}.
+     * @return The combined math transform, or {@code null} if no optimized combined
+     *         transform is available.
+     */
+    @Override
+    final MathTransform concatenate(final MathTransform other, final boolean applyOtherFirst) {
+        if (other instanceof LinearTransform) {
+            final LinearTransform1D linear = (LinearTransform1D) other;
+            if (applyOtherFirst) {
+                final double newBase  = Math.pow(base, linear.scale);
+                final double newScale = Math.pow(base, linear.offset) * scale;
+                if (!Double.isNaN(newBase) && !Double.isNaN(newScale)) {
+                    return create(newBase, newScale);
+                }
+            } else {
+                if (linear.offset == 0) {
+                    return create(base, scale * linear.scale);
+                }
+            }
+        } else if (other instanceof LogarithmicTransform1D) {
+            return concatenateLog((LogarithmicTransform1D) other, applyOtherFirst);
+        }
+        return super.concatenate(other, applyOtherFirst);
+    }
+
+    /**
+     * Concatenates in an optimized way a {@link LogarithmicTransform1D} {@code other}
+     * to this {@code ExponentialTransform1D}.
+     *
+     * @param  other The math transform to apply.
+     * @param  applyOtherFirst {@code true} if the transformation order is {@code other}
+     *         followed by {@code this}, or {@code false} if the transformation order is
+     *         {@code this} followed by {@code other}.
+     * @return The combined math transform, or {@code null} if no optimized combined
+     *         transform is available.
+     */
+    final MathTransform concatenateLog(final LogarithmicTransform1D other, final boolean applyOtherFirst) {
+        if (applyOtherFirst) {
+            return MathTransforms.concatenate(
+                    PowerTransform1D.create(lnBase / other.lnBase),
+                    LinearTransform1D.create(scale * Math.pow(base, other.offset), 0));
+        } else {
+            final double newScale = lnBase / other.lnBase;
+            final double newOffset;
+            if (scale > 0) {
+                newOffset = other.log(scale) + other.offset;
+            } else {
+                // Maybe the Math.log(...) argument will become
+                // positive if we rewrite the equation that way...
+                newOffset = other.log(scale * other.offset * other.lnBase);
+            }
+            if (!Double.isNaN(newOffset)) {
+                return LinearTransform1D.create(newScale, newOffset);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected int computeHashCode() {
+        return Numerics.hashCode(Double.doubleToLongBits(base) +
+                            31 * Double.doubleToLongBits(scale)) ^ super.computeHashCode();
+    }
+
+    /**
+     * Compares the specified object with this math transform for equality.
+     */
+    @Override
+    public boolean equals(final Object object, final ComparisonMode mode) {
+        if (object == this) {
+            return true; // Optimization for a common case.
+        }
+        if (super.equals(object, mode)) {
+            final ExponentialTransform1D that = (ExponentialTransform1D) object;
+            return Numerics.equals(this.base,  that.base) &&
+                   Numerics.equals(this.scale, that.scale);
+        }
+        return false;
+    }
+}

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1D.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8

Added: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java?rev=1601600&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java (added)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -0,0 +1,367 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.referencing.operation.transform;
+
+import java.io.Serializable;
+import org.opengis.referencing.operation.MathTransform;
+import org.opengis.referencing.operation.MathTransform1D;
+import org.apache.sis.internal.util.Numerics;
+import org.apache.sis.util.ArgumentChecks;
+import org.apache.sis.util.ComparisonMode;
+
+
+/**
+ * A one dimensional, logarithmic transform. This transform is the inverse of {@link ExponentialTransform1D}.
+ * Input values <var>x</var> are converted into output values <var>y</var> using the following equation:
+ *
+ * <blockquote><table class="compact" summary="y = offset + log(x)">
+ *   <tr><td><var>y</var></td><td> = </td><td>{@linkplain #offset} + log<sub>{@linkplain #base}</sub>(<var>x</var>)</td></tr>
+ *   <tr><td>            </td><td> = </td><td>{@linkplain #offset} + ln(<var>x</var>) / ln({@linkplain #base})</td></tr>
+ * </table></blockquote>
+ *
+ * {@section Serialization}
+ * Serialized instances of this class are not guaranteed to be compatible with future SIS versions.
+ * Serialization should be used only for short term storage or RMI between applications running the
+ * same SIS version.
+ *
+ * @author  Martin Desruisseaux (IRD, Geomatys)
+ * @since   0.5 (derived from geotk-2.0)
+ * @version 0.5
+ * @module
+ */
+class LogarithmicTransform1D extends AbstractMathTransform1D implements Serializable {
+    /**
+     * Serial number for inter-operability with different versions.
+     */
+    private static final long serialVersionUID = 1535101265352133948L;
+
+    /**
+     * The logarithm base.
+     */
+    protected final double base;
+
+    /**
+     * Natural logarithm of {@link #base}.
+     */
+    final double lnBase;
+
+    /**
+     * The offset to add to the logarithm.
+     *
+     * <span class="note"><b>Note:</b> the offset could be handled by a concatenation with {@link LinearTransform1D}.
+     * instead than an explicit field in this class. However the <var>offset</var> + log<sub>base</sub>(<var>x</var>)
+     * formula is extensively used as a <cite>transfer function</cite> in grid coverages. Consequently we keep this
+     * explicit field for performance reasons.</span>
+     */
+    protected final double offset;
+
+    /**
+     * The inverse of this transform. Created only when first needed. Serialized in order to avoid
+     * rounding error if this transform is actually the one which was created from the inverse.
+     */
+    private MathTransform1D inverse;
+
+    /**
+     * Constructs a new logarithmic transform which is the
+     * inverse of the supplied exponential transform.
+     *
+     * @see #create(ExponentialTransform1D)
+     */
+    private LogarithmicTransform1D(final ExponentialTransform1D inverse) {
+        this.base    = inverse.base;
+        this.lnBase  = inverse.lnBase;
+        this.offset  = -Math.log(inverse.scale) / lnBase;
+        this.inverse = inverse;
+    }
+
+    /**
+     * Constructs a new logarithmic transform. This constructor is provided for subclasses only.
+     * Instances should be created using the {@linkplain #create(double, double) factory method},
+     * which may return optimized implementations for some particular argument values.
+     *
+     * @param base    The base of the logarithm (typically 10).
+     * @param offset  The offset to add to the logarithm.
+     */
+    protected LogarithmicTransform1D(final double base, final double offset) {
+        ArgumentChecks.ensureStrictlyPositive("base", base);
+        this.base    = base;
+        this.offset  = offset;
+        this.lnBase  = Math.log(base);
+    }
+
+    /**
+     * Constructs a new logarithmic transform which include the given offset after the logarithm.
+     *
+     * @param  base    The base of the logarithm (typically 10).
+     * @param  offset  The offset to add to the logarithm.
+     * @return The math transform.
+     */
+    public static MathTransform1D create(final double base, final double offset) {
+        if (base == 10) {
+            return new Base10(offset);
+        }
+        if (base == 0) {
+            // offset + ln(x) / ln(0)   =   offset + ln(x) / -∞   =   offset + -0  for 0 < x < ∞
+            return LinearTransform1D.create(-0.0, offset);
+        }
+        if (base == Double.POSITIVE_INFINITY) {
+            // offset + ln(x) / ln(∞)   =   offset + ln(x) / +∞   =   offset + 0   for 0 < x < ∞
+            return LinearTransform1D.create(+0.0, offset);
+        }
+        return new LogarithmicTransform1D(base, offset);
+    }
+
+    /**
+     * Constructs a new logarithmic transform which is the inverse of the supplied exponential transform.
+     */
+    static LogarithmicTransform1D create(final ExponentialTransform1D inverse) {
+        if (inverse.base == 10) {
+            return new Base10(inverse);
+        }
+        return new LogarithmicTransform1D(inverse);
+    }
+
+    /**
+     * Creates the inverse transform of this object.
+     */
+    @Override
+    public synchronized MathTransform1D inverse() {
+        if (inverse == null) {
+            inverse = new ExponentialTransform1D(this);
+            // Above constructor will set ExponentialTransform1D.inverse = this.
+        }
+        return inverse;
+    }
+
+    /**
+     * Gets the derivative of this function at a value.
+     */
+    @Override
+    public double derivative(final double value) {
+        return 1 / (lnBase * value);
+    }
+
+    /**
+     * Returns the logarithm of the given value in the base given to this transform constructor.
+     * This method is similar to {@link #transform(double)} except that the offset is not added.
+     *
+     * @param  value The value for which to compute the log.
+     * @return The log of the given value in the base used by this transform.
+     */
+    double log(final double value) {
+        return Math.log(value) / lnBase;
+    }
+
+    /**
+     * Transforms the specified value.
+     */
+    @Override
+    public double transform(final double value) {
+        return Math.log(value) / lnBase + offset;
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final double[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
+        if (srcPts != dstPts || srcOff >= dstOff) {
+            while (--numPts >= 0) {
+                dstPts[dstOff++] = Math.log(srcPts[srcOff++]) / lnBase + offset;
+            }
+        } else {
+            srcOff += numPts;
+            dstOff += numPts;
+            while (--numPts >= 0) {
+                dstPts[--dstOff] = Math.log(srcPts[--srcOff]) / lnBase + offset;
+            }
+        }
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final float[] srcPts, int srcOff, final float[] dstPts, int dstOff, int numPts) {
+        if (srcPts != dstPts || srcOff >= dstOff) {
+            while (--numPts >= 0) {
+                dstPts[dstOff++] = (float) (Math.log(srcPts[srcOff++]) / lnBase + offset);
+            }
+        } else {
+            srcOff += numPts;
+            dstOff += numPts;
+            while (--numPts >= 0) {
+                dstPts[--dstOff] = (float) (Math.log(srcPts[--srcOff]) / lnBase + offset);
+            }
+        }
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final double[] srcPts, int srcOff, final float[] dstPts, int dstOff, int numPts) {
+        while (--numPts >= 0) {
+            dstPts[dstOff++] = (float) (Math.log(srcPts[srcOff++]) / lnBase + offset);
+        }
+    }
+
+    /**
+     * Transforms many coordinates in a list of ordinal values.
+     */
+    @Override
+    public void transform(final float[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
+        while (--numPts >= 0) {
+            dstPts[dstOff++] = Math.log(srcPts[srcOff++]) / lnBase + offset;
+        }
+    }
+
+    /**
+     * Special case for base 10 taking advantage of extra precision provided by {@link Math#log10(double)}.
+     */
+    private static final class Base10 extends LogarithmicTransform1D {
+        /** For cross-version compatibility. */
+        private static final long serialVersionUID = -5435804027536647558L;
+
+        /** Constructs the inverse of the supplied exponential transform. */
+        Base10(final ExponentialTransform1D inverse) {
+            super(inverse);
+        }
+
+        /** Creates a new instance with the given offset. */
+        protected Base10(final double offset) {
+            super(10, offset);
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        double log(final double value) {
+            return Math.log10(value);
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public double transform(final double value) {
+            return Math.log10(value) + offset;
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void transform(final double[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
+            if (srcPts != dstPts || srcOff >= dstOff) {
+                while (--numPts >= 0) {
+                    dstPts[dstOff++] = Math.log10(srcPts[srcOff++]) + offset;
+                }
+            } else {
+                srcOff += numPts;
+                dstOff += numPts;
+                while (--numPts >= 0) {
+                    dstPts[--dstOff] = Math.log10(srcPts[srcOff++]) + offset;
+                }
+            }
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void transform(final float[] srcPts, int srcOff, final float[] dstPts, int dstOff, int numPts) {
+            if (srcPts != dstPts || srcOff >= dstOff) {
+                while (--numPts >= 0) {
+                    dstPts[dstOff++] = (float) (Math.log10(srcPts[srcOff++]) + offset);
+                }
+            } else {
+                srcOff += numPts;
+                dstOff += numPts;
+                while (--numPts >= 0) {
+                    dstPts[--dstOff] = (float) (Math.log10(srcPts[srcOff++]) + offset);
+                }
+            }
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void transform(final double[] srcPts, int srcOff, final float[] dstPts, int dstOff, int numPts) {
+            while (--numPts >= 0) {
+                dstPts[dstOff++] = (float) (Math.log10(srcPts[srcOff++]) + offset);
+            }
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void transform(final float[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
+            while (--numPts >= 0) {
+                dstPts[dstOff++] = Math.log10(srcPts[srcOff++]) + offset;
+            }
+        }
+    }
+
+    /**
+     * Concatenates in an optimized way a {@link MathTransform} {@code other} to this
+     * {@code MathTransform}. This implementation can optimize some concatenation with
+     * {@link LinearTransform1D} and {@link ExponentialTransform1D}.
+     *
+     * @param  other The math transform to apply.
+     * @param  applyOtherFirst {@code true} if the transformation order is {@code other}
+     *         followed by {@code this}, or {@code false} if the transformation order is
+     *         {@code this} followed by {@code other}.
+     * @return The combined math transform, or {@code null} if no optimized combined
+     *         transform is available.
+     */
+    @Override
+    final MathTransform concatenate(final MathTransform other, final boolean applyOtherFirst) {
+        if (other instanceof LinearTransform) {
+            final LinearTransform1D linear = (LinearTransform1D) other;
+            if (applyOtherFirst) {
+                if (linear.offset == 0 && linear.scale > 0) {
+                    return create(base, Math.log(linear.scale) / lnBase + offset);
+                }
+            } else {
+                final double newBase = Math.pow(base, 1 / linear.scale);
+                if (!Double.isNaN(newBase)) {
+                    return create(newBase, linear.scale * offset + linear.offset);
+                }
+            }
+        } else if (other instanceof ExponentialTransform1D) {
+            return ((ExponentialTransform1D) other).concatenateLog(this, !applyOtherFirst);
+        }
+        return super.concatenate(other, applyOtherFirst);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected int computeHashCode() {
+        return Numerics.hashCode(Double.doubleToLongBits(base) +
+                            31 * Double.doubleToLongBits(offset)) ^ super.computeHashCode();
+    }
+
+    /**
+     * Compares the specified object with this math transform for equality.
+     */
+    @Override
+    public boolean equals(final Object object, final ComparisonMode mode) {
+        if (object == this) {
+            return true;  // Optimization for a common case.
+        }
+        if (super.equals(object, mode)) {
+            final LogarithmicTransform1D that = (LogarithmicTransform1D) object;
+            return Numerics.equals(this.base,   that.base) &&
+                   Numerics.equals(this.offset, that.offset);
+        }
+        return false;
+    }
+}

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LogarithmicTransform1D.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java?rev=1601600&r1=1601599&r2=1601600&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -69,11 +69,15 @@ public class PassThroughTransform extend
 
     /**
      * Index of the first affected ordinate.
+     *
+     * @see #getModifiedCoordinates()
      */
     final int firstAffectedOrdinate;
 
     /**
      * Number of unaffected ordinates after the affected ones.
+     *
+     * @see #getModifiedCoordinates()
      */
     final int numTrailingOrdinates;
 
@@ -253,9 +257,16 @@ public class PassThroughTransform extend
      * Returns the ordered sequence of positive integers defining the positions in a source
      * coordinate tuple of the coordinates affected by this pass-through operation.
      *
+     * <div class="note"><b>API note:</b> this method is final for now because most of Apache SIS code do
+     * not use the {@code modifiedCoordinates} array. Instead, SIS uses the {@code firstAffectedOrdinate}
+     * and {@code numTrailingOrdinates} information provided to the constructor. Consequently overriding
+     * this method may be misleading since it would be ignored by SIS. We do not want to make the "really
+     * used" fields public in order to keep the flexibility to replace them by a {@code modifiedCoordinates}
+     * array in a future SIS version.</div>
+     *
      * @return Indices of the modified source coordinates.
      */
-    public int[] getModifiedCoordinates() {
+    public final int[] getModifiedCoordinates() {
         final int[] index = new int[subTransform.getSourceDimensions()];
         for (int i=0; i<index.length; i++) {
             index[i] = i + firstAffectedOrdinate;

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PowerTransform1D.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PowerTransform1D.java?rev=1601600&r1=1601599&r2=1601600&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PowerTransform1D.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PowerTransform1D.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -31,6 +31,11 @@ import org.apache.sis.util.ComparisonMod
  * <p>Before to make this class public (if we do), we need to revisit the class name, define
  * parameters and improve the {@link #concatenate(MathTransform, boolean)} method.</p>
  *
+ * {@section Serialization}
+ * Serialized instances of this class are not guaranteed to be compatible with future SIS versions.
+ * Serialization should be used only for short term storage or RMI between applications running the
+ * same SIS version.
+ *
  * @author  Martin Desruisseaux (Geomatys)
  * @since   0.5 (derived from geotk-3.17)
  * @version 0.5
@@ -192,7 +197,7 @@ final class PowerTransform1D extends Abs
     @Override
     public boolean equals(final Object object, final ComparisonMode mode) {
         if (object == this) {
-            return true; // Slight optimization
+            return true;  // Optimization for a common case.
         }
         if (super.equals(object, mode)) {
             return Numerics.equals(power, ((PowerTransform1D) object).power);

Added: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java?rev=1601600&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java (added)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.referencing.operation.transform;
+
+import java.io.Serializable;
+import org.opengis.metadata.content.TransferFunctionType;
+import org.opengis.referencing.operation.MathTransform1D;
+import org.apache.sis.util.resources.Errors;
+
+
+/**
+ * The function converting <cite>sample values</cite> in a raster to <cite>geophysics values</cite>.
+ * The function is usually linear, but can sometime be logarithmic or exponential. The later occur
+ * most often when measuring concentration of something.
+ *
+ * <table class="sis">
+ *   <caption>Supported transfer functions</caption>
+ *   <tr><th>Type</th><th>Equation</th></tr>
+ *   <tr><td>{@link TransferFunctionType#LINEAR LINEAR}</td>
+ *       <td><var>y</var> = scale⋅<var>x</var> + offset</td></tr>
+ *   <tr><td>{@link TransferFunctionType#LOGARITHMIC LOGARITHMIC}</td>
+ *       <td><var>y</var> = scale⋅<b>log</b><sub>base</sub>(<var>x</var>) + offset</td></tr>
+ *   <tr><td>{@link TransferFunctionType#EXPONENTIAL EXPONENTIAL}</td>
+ *       <td><var>y</var> = scale⋅base<sup><var>x</var></sup> + offset</td></tr>
+ * </table>
+ *
+ * {@section Missing values}
+ * This {@code TransferFunction} class handles only the continuous part of transfer functions.
+ * This class does <strong>not</strong> handle missing values other than {@code NaN}.
+ * For a more complete class with support for non-NaN missing values,
+ * see {@link org.apache.sis.coverage.grid.GridSampleDimension}.
+ *
+ * {@section Serialization}
+ * Serialized instances of this class are not guaranteed to be compatible with future SIS versions.
+ * Serialization should be used only for short term storage or RMI between applications running the
+ * same SIS version.
+ *
+ * @author  Martin Desruisseaux (Geomatys)
+ * @since   0.5
+ * @version 0.5
+ * @module
+ */
+public class TransferFunction implements Cloneable, Serializable {
+    /**
+     * Whether the function is linear, logarithmic or exponential.
+     */
+    private TransferFunctionType type;
+
+    /**
+     * The logarithmic base. Ignored if {@link #type} is {@code LINEAR}.
+     */
+    private double base;
+
+    /**
+     * The scale factor, or {@code NaN} if unknown.
+     */
+    private double scale;
+
+    /**
+     * The scale factor, or {@code NaN} if unknown.
+     */
+    private double offset;
+
+    /**
+     * The transform created from above information, or {@code null} if not yet created.
+     * Conversely, may be the transform given to the constructor from which above information
+     * were inferred.
+     *
+     * <p>This field is serialized because the transform may be a user-provided one.</p>
+     */
+    private MathTransform1D transform;
+
+    /**
+     * Creates a transfer function initialized to the identity transform.
+     */
+    public TransferFunction() {
+        type  = TransferFunctionType.LINEAR;
+        base  = 10;
+        scale =  1;
+    }
+
+    /**
+     * Returns the transfer function type (linear, logarithmic or exponential).
+     *
+     * @return The transfer function type.
+     */
+    public TransferFunctionType getType() {
+        return type;
+    }
+
+    /**
+     * Sets the transfer function type.
+     * The default value is {@link TransferFunctionType#LINEAR}.
+     *
+     * @param type The transfer function type.
+     */
+    public void setType(final TransferFunctionType type) {
+        this.type = type;
+        transform = null;
+    }
+
+    /**
+     * Returns the logarithm or exponent base in the transfer function.
+     * This value is always 1 for {@link TransferFunctionType#LINEAR},
+     * and usually (but not necessarily) 10 for the other types.
+     *
+     * @return The logarithmic or exponent base.
+     */
+    public double getBase() {
+        return TransferFunctionType.LINEAR.equals(type) ? 1 : base;
+    }
+
+    /**
+     * Sets the logarithm or exponent base in the transfer function.
+     * This value is ignored for {@link TransferFunctionType#LINEAR}.
+     * For other supported types, the default value is 10.
+     *
+     * @param base The new logarithm or exponent base.
+     */
+    public void setBase(final double base) {
+        this.base = base;
+        transform = null;
+    }
+
+    /**
+     * Returns the scale factor of the transfer function.
+     *
+     * @return The scale factor.
+     */
+    public double getScale() {
+        return scale;
+    }
+
+    /**
+     * Sets the scale factor of the transfer function.
+     * The default value is 1.
+     *
+     * @param scale The new scale factor.
+     */
+    public void setScale(final double scale) {
+        this.scale = scale;
+        transform = null;
+    }
+
+    /**
+     * Returns the offset of the transfer function.
+     *
+     * @return The offset.
+     */
+    public double getOffset() {
+        return offset;
+    }
+
+    /**
+     * Sets the offset of the transfer function.
+     * The default value is 0.
+     *
+     * @param offset The new offset.
+     */
+    public void setOffset(final double offset) {
+        this.offset = offset;
+        transform = null;
+    }
+
+    /**
+     * Returns the transform from sample values to geophysics values, as specified by the
+     * current properties of this {@code TransferFunction}.
+     *
+     * @return The transform from sample to geophysics values.
+     */
+    public MathTransform1D getTransform() {
+        if (transform == null) {
+            if (TransferFunctionType.LINEAR.equals(type)) {
+                transform = LinearTransform1D.create(scale, offset);
+            } else if (TransferFunctionType.EXPONENTIAL.equals(type)) {
+                transform = ExponentialTransform1D.create(base, scale);
+                if (offset != 0) {  // Rarely occurs in practice.
+                    transform = (MathTransform1D) ConcatenatedTransform.create(
+                            transform, LinearTransform1D.create(0, offset));
+                }
+            } else if (TransferFunctionType.LOGARITHMIC.equals(type)) {
+                if (scale == 1) {
+                    transform = LogarithmicTransform1D.create(base, offset);
+                } else {
+                    /*
+                     * This case rarely occurs in practice, so we do not provide optimized constructor.
+                     * The ExponentialTransform1D.concatenate(…) method will rewrite the equation using
+                     * mathematical identities. The result will be a function with a different base.
+                     */
+                    transform = (MathTransform1D) ConcatenatedTransform.create(
+                            LogarithmicTransform1D.create(base, 0),
+                            LinearTransform1D.create(scale, offset));
+                }
+            } else {
+                throw new IllegalStateException(Errors.format(Errors.Keys.UnknownType_1, type));
+            }
+        }
+        return transform;
+    }
+}

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TransferFunction.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8

Added: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java?rev=1601600&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java (added)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.referencing.operation.transform;
+
+import org.opengis.referencing.operation.MathTransform1D;
+import org.opengis.referencing.operation.TransformException;
+import org.apache.sis.test.DependsOn;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import static java.lang.StrictMath.*;
+
+
+/**
+ * Tests the {@link ExponentialTransform1D} class. This test case will also tests
+ * indirectly the {@link LogarithmicTransform1D} class since it is the inverse of
+ * the exponential transform.
+ *
+ * @author  Martin Desruisseaux (Geomatys)
+ * @since   0.5 (derived from geotk-3.17)
+ * @version 0.5
+ * @module
+ */
+@DependsOn(LinearTransformTest.class)
+public final strictfp class ExponentialTransform1DTest extends MathTransformTestCase {
+    /**
+     * Arbitrary coefficients used for this test.
+     */
+    private static final double BASE = 10, SCALE = 2, C0 = -3, C1 = 0.25;
+
+    /**
+     * A simple (non-concatenated) test case.
+     *
+     * @throws TransformException should never happen.
+     */
+    @Test
+    public void testSimple() throws TransformException {
+        transform = ExponentialTransform1D.create(BASE, SCALE);
+        validate();
+        assertFalse(transform.isIdentity());
+        final double[] source = generateRandomCoordinates(CoordinateDomain.GAUSSIAN, 0);
+        final double[] target = new double[source.length];
+        for (int i=0; i<source.length; i++) {
+            target[i] = SCALE * pow(BASE, source[i]);
+        }
+        tolerance = 1E-12;
+        verifyTransform(source, target);
+        /*
+         * Tests the derivative at a single point.
+         */
+        tolerance = 0.002;
+        derivativeDeltas = new double[] {0.001};
+        verifyDerivative(2.5);
+    }
+
+    /**
+     * Tests the concatenation of a linear operation before the exponential one.
+     *
+     * @throws TransformException should never happen.
+     */
+    @Test
+    public void testAffinePreConcatenation() throws TransformException {
+        transform = MathTransforms.concatenate(
+                LinearTransform1D.create(C1, C0),
+                ExponentialTransform1D.create(BASE, SCALE));
+        validate();
+        assertFalse(transform.isIdentity());
+        assertTrue("Expected mathematical identities.", transform instanceof ExponentialTransform1D);
+        final double[] source = generateRandomCoordinates(CoordinateDomain.GAUSSIAN, 0);
+        final double[] target = new double[source.length];
+        for (int i=0; i<source.length; i++) {
+            target[i] = SCALE * pow(BASE, C0 + C1 * source[i]);
+        }
+        tolerance = 1E-14;
+        verifyTransform(source, target);
+        /*
+         * Tests the derivative at a single point.
+         */
+        tolerance = 1E-9;
+        derivativeDeltas = new double[] {0.001};
+        verifyDerivative(2.5);
+        /*
+         * Find back the original linear coefficients as documented in the ExpentionalTransform1D
+         * class javadoc. Then check that the transform results are the expected ones.
+         */
+        final double lnBase =  log(BASE);
+        final double offset = -log(SCALE) / lnBase;
+        final MathTransform1D log = LogarithmicTransform1D.create(BASE, offset);
+        transform = (LinearTransform1D) MathTransforms.concatenate(transform, log);
+        assertTrue("Expected mathematical identities.", transform instanceof LinearTransform1D);
+        assertEquals(C1, ((LinearTransform1D) transform).scale,  1E-12);
+        assertEquals(C0, ((LinearTransform1D) transform).offset, 1E-12);
+        for (int i=0; i<source.length; i++) {
+            target[i] = log(target[i]) / lnBase + offset;
+        }
+        tolerance = 1E-14;
+        verifyTransform(source, target);
+    }
+
+    /**
+     * Tests the concatenation of a linear operation after the exponential one.
+     *
+     * @throws TransformException should never happen.
+     */
+    @Test
+    public void testAffinePostConcatenation() throws TransformException {
+        transform = MathTransforms.concatenate(
+                ExponentialTransform1D.create(BASE, SCALE),
+                LinearTransform1D.create(C1, C0));
+        validate();
+        assertFalse(transform.isIdentity());
+        final double[] source = generateRandomCoordinates(CoordinateDomain.GAUSSIAN, 0);
+        final double[] target = new double[source.length];
+        for (int i=0; i<source.length; i++) {
+            target[i] = C0 + C1 * (SCALE * pow(BASE, source[i]));
+        }
+        tolerance = 1E-12;
+        verifyTransform(source, target);
+        /*
+         * Tests the derivative at a single point.
+         */
+        tolerance = 0.01;
+        derivativeDeltas = new double[] {0.001};
+        verifyDerivative(2.5);
+    }
+
+    /**
+     * Tests the concatenation of a logarithmic operation with the exponential one.
+     *
+     * @throws TransformException should never happen.
+     */
+    @Test
+    public void testLogarithmicConcatenation() throws TransformException {
+        final double offset = -3;
+        final double base   = 8;
+        final double lnBase = log(base);
+        transform = MathTransforms.concatenate(
+                LogarithmicTransform1D.create(base, offset),
+                ExponentialTransform1D.create(BASE, SCALE));
+        validate();
+        assertFalse(transform.isIdentity());
+        final double[] source = generateRandomCoordinates(CoordinateDomain.GAUSSIAN, 0);
+        final double[] target = new double[source.length];
+        for (int i=0; i<source.length; i++) {
+            source[i] = abs(source[i]) + 0.001;
+            target[i] = SCALE * pow(BASE, log(source[i]) / lnBase + offset);
+        }
+        tolerance = 1E-14;
+        verifyTransform(source, target);
+        /*
+         * Tests the derivative at a single point.
+         */
+        tolerance = 1E-10;
+        derivativeDeltas = new double[] {0.001};
+        verifyDerivative(2.5);
+    }
+}

Propchange: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ExponentialTransform1DTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PassThroughTransformTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PassThroughTransformTest.java?rev=1601600&r1=1601599&r2=1601600&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PassThroughTransformTest.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PassThroughTransformTest.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -44,7 +44,10 @@ import org.opengis.test.ToleranceModifie
  * @version 0.5
  * @module
  */
-@DependsOn(LinearTransformTest.class)
+@DependsOn({
+    LinearTransformTest.class,
+    ExponentialTransform1DTest.class
+})
 public final strictfp class PassThroughTransformTest extends MathTransformTestCase {
     /**
      * The random number generator to be used in this test.

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java?rev=1601600&r1=1601599&r2=1601600&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java [UTF-8] Tue Jun 10 10:36:56 2014
@@ -44,6 +44,7 @@ import org.junit.BeforeClass;
     org.apache.sis.referencing.operation.transform.AbstractMathTransformTest.class,
     org.apache.sis.referencing.operation.transform.ProjectiveTransformTest.class,
     org.apache.sis.referencing.operation.transform.LinearTransformTest.class,
+    org.apache.sis.referencing.operation.transform.ExponentialTransform1DTest.class,
     org.apache.sis.referencing.operation.transform.CopyTransformTest.class,
     org.apache.sis.referencing.operation.transform.PassThroughTransformTest.class,
 



Mime
View raw message