sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1713510 [1/2] - in /sis/branches/JDK8: core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/ core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/ core/sis-referencing/src/main/java/org/apache/sis/...
Date Mon, 09 Nov 2015 18:55:57 GMT
Author: desruisseaux
Date: Mon Nov  9 18:55:56 2015
New Revision: 1713510

URL: http://svn.apache.org/viewvc?rev=1713510&view=rev
Log:
Replace "excentricity" spelling by "eccentricity".

Modified:
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/MapProjection.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/Molodensky.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ConformalProjection.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Initializer.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/LambertConicConformal.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Mercator.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ObliqueStereographic.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/PolarStereographic.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/TransverseMercator.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/EllipsoidalToCartesianTransform.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeocentricTranslationTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ConformalProjectionTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/LambertConicConformalTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/MercatorMethodComparison.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/MercatorTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/NormalizedProjectionTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ObliqueStereographicTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ProjectionResultComparator.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/EllipsoidalToCartesianTransformTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/MolodenskyTransformTest.java
    sis/branches/JDK8/ide-project/NetBeans/nbproject/project.xml

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/MapProjection.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/MapProjection.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/MapProjection.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/MapProjection.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -83,11 +83,11 @@ public abstract class MapProjection exte
     public static final DefaultParameterDescriptor<Double> SEMI_MINOR;
 
     /**
-     * The ellipsoid excentricity, computed from the semi-major and semi-minor axis lengths.
+     * The ellipsoid eccentricity, computed from the semi-major and semi-minor axis lengths.
      * This a SIS-specific parameter used mostly for debugging purpose.
      */
     @Debug
-    public static final DefaultParameterDescriptor<Double> EXCENTRICITY;
+    public static final DefaultParameterDescriptor<Double> ECCENTRICITY;
     static {
         final MeasurementRange<Double> valueDomain = MeasurementRange.createGreaterThan(0, SI.METRE);
         final GenericName[] aliases = {
@@ -116,8 +116,8 @@ public abstract class MapProjection exte
          */
         properties.clear();
         properties.put(AUTHORITY_KEY, Citations.SIS);
-        properties.put(NAME_KEY, "excentricity");
-        EXCENTRICITY = new DefaultParameterDescriptor<>(properties, 1, 1, Double.class,
+        properties.put(NAME_KEY, "eccentricity");
+        ECCENTRICITY = new DefaultParameterDescriptor<>(properties, 1, 1, Double.class,
                 MeasurementRange.create(0d, true, 1d, true, null), null, null);
     }
 

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/Molodensky.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/Molodensky.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/Molodensky.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/Molodensky.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -114,7 +114,7 @@ public final class Molodensky extends Ge
     /**
      * Creates a descriptor for the internal parameters of {@link MolodenskyTransform}.
      * This is identical to the standard parameters except that the last 3 OGC parameters
-     * are replaced by the excentricity.
+     * are replaced by the eccentricity.
      *
      * @return Internal parameter descriptor.
      */
@@ -130,7 +130,7 @@ public final class Molodensky extends Ge
                              AXIS_LENGTH_DIFFERENCE,
                              FLATTENING_DIFFERENCE,
                              SRC_SEMI_MAJOR,
-                             MapProjection.EXCENTRICITY,
+                             MapProjection.ECCENTRICITY,
                              abridged);
     }
 

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -407,7 +407,7 @@ public class DefaultEllipsoid extends Ab
      * @return ℯ, the eccentricity of this ellipsoid.
      */
     public double getEccentricity() {
-        final DoubleDouble e = excentricitySquared();
+        final DoubleDouble e = eccentricitySquared();
         e.sqrt();
         return e.value;
     }
@@ -425,7 +425,7 @@ public class DefaultEllipsoid extends Ab
      * @since 0.7
      */
     public double getEccentricitySquared() {
-        return excentricitySquared().value;
+        return eccentricitySquared().value;
     }
 
     /**
@@ -436,13 +436,13 @@ public class DefaultEllipsoid extends Ab
      * second defining parameter.  But even if the second defining parameter of this ellipsoid was rather the
      * semi-minor axis, the fact that we use double-double arithmetic should give the same result anyway.</div>
      */
-    private DoubleDouble excentricitySquared() {
+    private DoubleDouble eccentricitySquared() {
         final DoubleDouble f = flattening(this);
-        final DoubleDouble excentricitySquared = new DoubleDouble(f);
-        excentricitySquared.multiply(2, 0);
+        final DoubleDouble eccentricitySquared = new DoubleDouble(f);
+        eccentricitySquared.multiply(2, 0);
         f.square();
-        excentricitySquared.subtract(f);
-        return excentricitySquared;
+        eccentricitySquared.subtract(f);
+        return eccentricitySquared;
     }
 
     /**

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ConformalProjection.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ConformalProjection.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ConformalProjection.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ConformalProjection.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -100,7 +100,7 @@ abstract class ConformalProjection exten
     static final boolean ALLOW_TRIGONOMETRIC_IDENTITIES = true;
 
     /**
-     * The threshold value of {@link #excentricity} at which we consider the accuracy of the
+     * The threshold value of {@link #eccentricity} at which we consider the accuracy of the
      * series expansion insufficient. This threshold is determined empirically with the help
      * of the {@code MercatorMethodComparison} class in the test directory.
      * We choose the value where:
@@ -110,10 +110,10 @@ abstract class ConformalProjection exten
      *   <li>the maximal error of series expansion become greater than {@link NormalizedProjection#ANGULAR_TOLERANCE}.</li>
      * </ul>
      */
-    static final double EXCENTRICITY_THRESHOLD = 0.16;
+    static final double ECCENTRICITY_THRESHOLD = 0.16;
 
     /**
-     * {@code true} if the {@link #excentricity} value is greater than or equals to {@link #EXCENTRICITY_THRESHOLD},
+     * {@code true} if the {@link #eccentricity} value is greater than or equals to {@link #ECCENTRICITY_THRESHOLD},
      * in which case the {@link #φ(double)} method will need to use an iterative method.
      *
      * <p><strong>Consider this field as final!</strong>
@@ -125,7 +125,7 @@ abstract class ConformalProjection exten
 
     /**
      * Coefficients in the series expansion of the inverse projection,
-     * depending only on {@linkplain #excentricity excentricity} value.
+     * depending only on {@linkplain #eccentricity eccentricity} value.
      * The series expansion is of the following form, where f(θ) is typically sin(θ):
      *
      *     <blockquote>ci₂⋅f(2θ) + ci₄⋅f(4θ) + ci₆⋅f(6θ) + ci₈⋅f(8θ)</blockquote>
@@ -154,18 +154,18 @@ abstract class ConformalProjection exten
     }
 
     /**
-     * Computes the coefficients in the series expansions from the {@link #excentricitySquared} value.
+     * Computes the coefficients in the series expansions from the {@link #eccentricitySquared} value.
      * This method shall be invoked after {@code ConformalProjection} construction or deserialization.
      */
     void computeCoefficients() {
-        useIterations = (excentricity >= EXCENTRICITY_THRESHOLD);
-        final double e2 = excentricitySquared;
+        useIterations = (eccentricity >= ECCENTRICITY_THRESHOLD);
+        final double e2 = eccentricitySquared;
         final double e4 = e2 * e2;
         final double e6 = e2 * e4;
         final double e8 = e4 * e4;
         /*
          * For each line below, add the smallest values first in order to reduce rounding errors.
-         * The smallest values are the one using the excentricity raised to the highest power.
+         * The smallest values are the one using the eccentricity raised to the highest power.
          */
         ci2  =    13/   360.* e8  +   1/ 12.* e6  +  5/24.* e4  +  e2/2;
         ci4  =   811/ 11520.* e8  +  29/240.* e6  +  7/48.* e4;
@@ -224,7 +224,7 @@ abstract class ConformalProjection exten
      *
      * <b>Note:</b> §1.3.3 in Geomatics Guidance Note number 7 part 2 (April 2015) uses a series expansion
      * while USGS used an iterative method. The series expansion is twice faster than the iterative method
-     * for the same precision, but this precision is achieved "only" for relatively small excentricity like
+     * for the same precision, but this precision is achieved "only" for relatively small eccentricity like
      * the Earth's one. See the {@code MercatorMethodComparison} class in the test package for more discussion.
      *
      * @param  expOfSouthing The <em>reciprocal</em> of the value returned by {@link #expOfNorthing}.
@@ -237,7 +237,7 @@ abstract class ConformalProjection exten
     final double φ(final double expOfSouthing) throws ProjectionException {
         /*
          * Get a first approximation of φ from Snyder (7-11). The result below would be exact if the
-         * ellipsoid was actually a sphere. But if the excentricity is different than 0, then we will
+         * ellipsoid was actually a sphere. But if the eccentricity is different than 0, then we will
          * need to add a correction.
          *
          * Note that the φ value computed by the line below is called χ in EPSG guide.
@@ -275,15 +275,15 @@ abstract class ConformalProjection exten
         }
         /*
          * We should never reach this point for map projections on Earth. But if the ellipsoid is for some
-         * other planet having a high excentricity, then the above series expansion may not be sufficient.
+         * other planet having a high eccentricity, then the above series expansion may not be sufficient.
          * Try to improve by iteratively solving equation (7-9) from Snyder. However instead than using
          * Snyder (7-11) as the starting point, we take the result of above calculation as the initial φ.
          * Assuming that it is closer to the real φ value, this save us some iteration loops and usually
          * gives us more accurate results (according MercatorMethodComparison tests).
          */
-        final double hℯ = 0.5 * excentricity;
+        final double hℯ = 0.5 * eccentricity;
         for (int it=0; it<MAXIMUM_ITERATIONS; it++) {
-            final double ℯsinφ = excentricity * sin(φ);
+            final double ℯsinφ = eccentricity * sin(φ);
             final double Δφ = φ - (φ = PI/2 - 2*atan(expOfSouthing * pow((1 - ℯsinφ)/(1 + ℯsinφ), hℯ)));
             if (!(abs(Δφ) > ITERATION_TOLERANCE)) {     // Use '!' for accepting NaN.
                 return φ;
@@ -344,7 +344,7 @@ abstract class ConformalProjection exten
      * </ul>
      *
      * @param  φ     The latitude in radians.
-     * @param  ℯsinφ The sine of the φ argument multiplied by {@link #excentricity}.
+     * @param  ℯsinφ The sine of the φ argument multiplied by {@link #eccentricity}.
      * @return {@code Math.exp} of the Mercator projection of the given latitude.
      *
      * @see #φ(double)
@@ -358,7 +358,7 @@ abstract class ConformalProjection exten
          * favorises slightly the North hemisphere (but the differences are very small). In Apache SIS,
          * we handle that by changing the sign of some terms in the (de)normalisation matrices.
          */
-        return tan(PI/4 + 0.5*φ) * pow((1 - ℯsinφ) / (1 + ℯsinφ), 0.5*excentricity);
+        return tan(PI/4 + 0.5*φ) * pow((1 - ℯsinφ) / (1 + ℯsinφ), 0.5*eccentricity);
     }
 
     /**
@@ -376,7 +376,7 @@ abstract class ConformalProjection exten
      * @see #φ(double)
      */
     final double dy_dφ(final double sinφ, final double cosφ) {
-        return (1 / cosφ)  -  excentricitySquared * cosφ / (1 - excentricitySquared * (sinφ*sinφ));
+        return (1 / cosφ)  -  eccentricitySquared * cosφ / (1 - eccentricitySquared * (sinφ*sinφ));
     }
 
     /**

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Initializer.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Initializer.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Initializer.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Initializer.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -42,7 +42,7 @@ import static org.apache.sis.internal.ut
  *
  * <ul>
  *   <li>To convert degrees to radians, than back to degrees and find the original value.</li>
- *   <li>To convert axis length (optionally with flattening factor) to excentricity, then back
+ *   <li>To convert axis length (optionally with flattening factor) to eccentricity, then back
  *       to axis length and find the original value.</li>
  * </ul>
  *
@@ -75,8 +75,8 @@ final class Initializer {
     final Parameters parameters;
 
     /**
-     * The square of excentricity: ℯ² = (a²-b²)/a² where
-     * <var>ℯ</var> is the {@linkplain #excentricity excentricity},
+     * The square of eccentricity: ℯ² = (a²-b²)/a² where
+     * <var>ℯ</var> is the {@linkplain #eccentricity eccentricity},
      * <var>a</var> is the <cite>semi-major</cite> axis length and
      * <var>b</var> is the <cite>semi-minor</cite> axis length.
      *
@@ -85,7 +85,7 @@ final class Initializer {
      * {@code double} parameter value without rounding errors. This wish usually do not apply to other internal
      * {@link NormalizedProjection} parameters.</p>
      */
-    final DoubleDouble excentricitySquared;
+    final DoubleDouble eccentricitySquared;
 
     /**
      * Map projection variant. This is a convenience field left at
@@ -130,7 +130,7 @@ final class Initializer {
         final double fn = getAndStore(roles.get(ParameterRole.FALSE_NORTHING))
                         - getAndStore(roles.get(ParameterRole.FALSE_SOUTHING));
 
-        excentricitySquared = new DoubleDouble();
+        eccentricitySquared = new DoubleDouble();
         DoubleDouble k = new DoubleDouble(a);  // The value by which to multiply all results of normalized projection.
         if (a != b) {
             /*
@@ -161,16 +161,16 @@ final class Initializer {
             if (isIvfDefinitive) {
                 final DoubleDouble f = new DoubleDouble(parameters.parameter(Constants.INVERSE_FLATTENING).doubleValue());
                 f.inverseDivide(1,0);
-                excentricitySquared.setFrom(f);
-                excentricitySquared.multiply(2,0);
+                eccentricitySquared.setFrom(f);
+                eccentricitySquared.multiply(2,0);
                 f.square();
-                excentricitySquared.subtract(f);
+                eccentricitySquared.subtract(f);
             } else {
                 final DoubleDouble rs = new DoubleDouble(b);
                 rs.divide(k);    // rs = b/a
                 rs.square();
-                excentricitySquared.value = 1;
-                excentricitySquared.subtract(rs);
+                eccentricitySquared.value = 1;
+                eccentricitySquared.subtract(rs);
             }
             final ParameterDescriptor<? extends Number> radius = roles.get(ParameterRole.LATITUDE_OF_CONFORMAL_SPHERE_RADIUS);
             if (radius != null) {
@@ -188,7 +188,7 @@ final class Initializer {
                  * Equivalent Java code:
                  *
                  *     final double sinφ = sin(toRadians(parameters.doubleValue(radius)));
-                 *     k = b / (1 - excentricitySquared * (sinφ*sinφ));
+                 *     k = b / (1 - eccentricitySquared * (sinφ*sinφ));
                  */
                 k = rν2(sin(toRadians(parameters.doubleValue(radius))));
                 k.inverseDivide(b, 0);
@@ -255,11 +255,11 @@ final class Initializer {
 
     /**
      * Returns {@code b/a} where {@code a} is the semi-major axis length and {@code b} the semi-minor axis length.
-     * We retrieve this value from the excentricity with {@code b/a = sqrt(1-ℯ²)}.
+     * We retrieve this value from the eccentricity with {@code b/a = sqrt(1-ℯ²)}.
      */
     final DoubleDouble axisLengthRatio() {
         final DoubleDouble b = new DoubleDouble(1,0);
-        b.subtract(excentricitySquared);
+        b.subtract(eccentricitySquared);
         b.sqrt();
         return b;
     }
@@ -291,11 +291,11 @@ final class Initializer {
      */
     private DoubleDouble rν2(final double sinφ) {
         if (DoubleDouble.DISABLED) {
-            return verbatim(1 - excentricitySquared.value * (sinφ*sinφ));
+            return verbatim(1 - eccentricitySquared.value * (sinφ*sinφ));
         }
         final DoubleDouble t = verbatim(sinφ);
         t.square();
-        t.multiply(excentricitySquared);
+        t.multiply(eccentricitySquared);
 
         // Compute 1 - ℯ²⋅sin²φ.  Since  ℯ²⋅sin²φ  may be small,
         // this is where double-double arithmetic has more value.
@@ -320,7 +320,7 @@ final class Initializer {
      */
     final double radiusOfConformalSphere(final double sinφ) {
         final DoubleDouble Rc = verbatim(1);
-        Rc.subtract(excentricitySquared);       //  1 - ℯ²
+        Rc.subtract(eccentricitySquared);       //  1 - ℯ²
         Rc.sqrt();                              //  √(1 - ℯ²)
         Rc.divide(rν2(sinφ));                   //  √(1 - ℯ²) / (1 - ℯ²sin²φ)
         return Rc.value;

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/LambertConicConformal.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/LambertConicConformal.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/LambertConicConformal.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/LambertConicConformal.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -262,13 +262,13 @@ public class LambertConicConformal exten
         φ2 = toRadians(φ2);
         /*
          * Compute constants. We do not need to use special formulas for the spherical case below,
-         * since rν(sinφ) = 1 and expOfNorthing(φ) = tan(π/4 + φ/2) when the excentricity is zero.
+         * since rν(sinφ) = 1 and expOfNorthing(φ) = tan(π/4 + φ/2) when the eccentricity is zero.
          * However we need special formulas for φ1 ≈ φ2 in the calculation of n, otherwise we got
          * a 0/0 indetermination.
          */
         final double sinφ1 = sin(φ1);
         final double m1 = initializer.scaleAtφ(sinφ1, cos(φ1));
-        final double t1 = expOfNorthing(φ1, excentricity*sinφ1);
+        final double t1 = expOfNorthing(φ1, eccentricity*sinφ1);
         /*
          * Compute n = (ln m₁ – ln m₂) / (ln t₁ – ln t₂), which we rewrite as ln(m₁/m₂) / ln(t₁/t₂)
          * for reducing the amount of calls to the logarithmic function. Note that this equation
@@ -277,7 +277,7 @@ public class LambertConicConformal exten
         if (abs(φ1 - φ2) >= ANGULAR_TOLERANCE) {  // Should be 'true' for 2SP case.
             final double sinφ2 = sin(φ2);
             final double m2 = initializer.scaleAtφ(sinφ2, cos(φ2));
-            final double t2 = expOfNorthing(φ2, excentricity*sinφ2);
+            final double t2 = expOfNorthing(φ2, eccentricity*sinφ2);
             n = log(m1/m2) / log(t1/t2);    // Tend toward 0/0 if φ1 ≈ φ2.
         } else {
             n = -sinφ1;
@@ -306,7 +306,7 @@ public class LambertConicConformal exten
         DoubleDouble rF = null;
         if (φ0 != copySign(PI/2, -n)) {    // For reducing the rounding error documented in expOfNorthing(+π/2).
             rF = new DoubleDouble(F);
-            rF.multiply(pow(expOfNorthing(φ0, excentricity*sin(φ0)), n), 0);
+            rF.multiply(pow(expOfNorthing(φ0, eccentricity*sin(φ0)), n), 0);
         }
         /*
          * At this point, all parameters have been processed. Now store
@@ -382,7 +382,7 @@ public class LambertConicConformal exten
     @Override
     public MathTransform createMapProjection(final MathTransformFactory factory) throws FactoryException {
         LambertConicConformal kernel = this;
-        if (excentricity == 0) {
+        if (eccentricity == 0) {
             kernel = new Spherical(this);
         }
         return context.completeTransform(factory, kernel);
@@ -415,7 +415,7 @@ public class LambertConicConformal exten
         final double ρ;     // EPSG guide uses "r", but we keep the symbol from Snyder p. 108 for consistency with PolarStereographic.
         if (absφ < PI/2) {
             sinφ = sin(φ);
-            ρ = pow(expOfNorthing(φ, excentricity*sinφ), n);
+            ρ = pow(expOfNorthing(φ, eccentricity*sinφ), n);
         } else if (absφ < PI/2 + ANGULAR_TOLERANCE) {
             sinφ = 1;
             ρ = (φ*n >= 0) ? POSITIVE_INFINITY : 0;

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Mercator.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Mercator.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Mercator.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/Mercator.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -258,7 +258,7 @@ public class Mercator extends ConformalP
             denormalize.convertBefore(0, null, offset);
         }
         if (φ0 != 0) {
-            denormalize.convertBefore(1, null, verbatim(-log(expOfNorthing(φ0, excentricity * sin(φ0)))));
+            denormalize.convertBefore(1, null, verbatim(-log(expOfNorthing(φ0, eccentricity * sin(φ0)))));
         }
         if (variant == MILLER) {
             normalize  .convertBefore(1, 0.80, null);
@@ -317,7 +317,7 @@ public class Mercator extends ConformalP
     @Override
     public MathTransform createMapProjection(final MathTransformFactory factory) throws FactoryException {
         Mercator kernel = this;
-        if ((variant & SPHERICAL) != 0 || excentricity == 0) {
+        if ((variant & SPHERICAL) != 0 || eccentricity == 0) {
             kernel = new Spherical(this);
         }
         return context.completeTransform(factory, kernel);
@@ -353,7 +353,7 @@ public class Mercator extends ConformalP
                 // about why we perform explicit checks for the pole cases.
                 final double a = abs(φ);
                 if (a < PI/2) {
-                    y = log(expOfNorthing(φ, excentricity * sinφ));     // Snyder (7-7)
+                    y = log(expOfNorthing(φ, eccentricity * sinφ));     // Snyder (7-7)
                 } else {
                     y = copySign(a <= (PI/2 + ANGULAR_TOLERANCE) ? POSITIVE_INFINITY : NaN, φ);
                 }
@@ -394,7 +394,7 @@ public class Mercator extends ConformalP
                     final double a = abs(φ);
                     final double y;
                     if (a < PI/2) {
-                        y = log(expOfNorthing(φ, excentricity * sin(φ)));
+                        y = log(expOfNorthing(φ, eccentricity * sin(φ)));
                     } else {
                         y = copySign(a <= (PI/2 + ANGULAR_TOLERANCE) ? POSITIVE_INFINITY : NaN, φ);
                     }

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -162,14 +162,14 @@ public abstract class NormalizedProjecti
     /**
      * Maximum number of iterations for iterative computations.
      * The iterative methods used in subclasses should converge quickly (in 3 or 4 iterations)
-     * when used for a planet with an excentricity similar to Earth. But we allow a high limit
-     * in case someone uses SIS for some planet with higher excentricity.
+     * when used for a planet with an eccentricity similar to Earth. But we allow a high limit
+     * in case someone uses SIS for some planet with higher eccentricity.
      */
     static final int MAXIMUM_ITERATIONS = Formulas.MAXIMUM_ITERATIONS;
 
     /**
      * The internal parameter descriptors. Keys are implementation classes.  Values are parameter descriptor groups
-     * containing at least a parameter for the {@link #excentricity} value, and optionally other internal parameter
+     * containing at least a parameter for the {@link #eccentricity} value, and optionally other internal parameter
      * added by some subclasses.
      *
      * <p>Entries are created only when first needed. Those descriptors are usually never created since they are
@@ -188,18 +188,18 @@ public abstract class NormalizedProjecti
     final ContextualParameters context;
 
     /**
-     * Ellipsoid excentricity, equals to <code>sqrt({@linkplain #excentricitySquared})</code>.
+     * Ellipsoid eccentricity, equals to <code>sqrt({@linkplain #eccentricitySquared})</code>.
      * Value 0 means that the ellipsoid is spherical.
      */
-    protected final double excentricity;
+    protected final double eccentricity;
 
     /**
-     * The square of excentricity: ℯ² = (a²-b²)/a² where
-     * <var>ℯ</var> is the {@linkplain #excentricity excentricity},
+     * The square of eccentricity: ℯ² = (a²-b²)/a² where
+     * <var>ℯ</var> is the {@linkplain #eccentricity eccentricity},
      * <var>a</var> is the <cite>semi-major</cite> axis length and
      * <var>b</var> is the <cite>semi-minor</cite> axis length.
      */
-    protected final double excentricitySquared;
+    protected final double eccentricitySquared;
 
     /**
      * The inverse of this map projection.
@@ -233,7 +233,7 @@ public abstract class NormalizedProjecti
     protected static enum ParameterRole {
         /**
          * Maps the <cite>semi-major axis length</cite> parameter (symbol: <var>a</var>).
-         * This value is used for computing {@link NormalizedProjection#excentricity},
+         * This value is used for computing {@link NormalizedProjection#eccentricity},
          * and is also a multiplication factor for the denormalization matrix.
          *
          * <p>Unless specified otherwise, this is always mapped to a parameter named {@code "semi_major"}.
@@ -243,7 +243,7 @@ public abstract class NormalizedProjecti
 
         /**
          * Maps the <cite>semi-minor axis length</cite> parameter (symbol: <var>b</var>).
-         * This value is used for computing {@link NormalizedProjection#excentricity}.
+         * This value is used for computing {@link NormalizedProjection#eccentricity}.
          *
          * <p>Unless specified otherwise, this is always mapped to a parameter named {@code "semi_minor"}.
          * {@code NormalizedProjection} subclasses typically do not need to provide a value for this key.</p>
@@ -420,8 +420,8 @@ public abstract class NormalizedProjecti
      */
     NormalizedProjection(final Initializer initializer) {
         context             = initializer.context;
-        excentricitySquared = initializer.excentricitySquared.value;
-        excentricity        = sqrt(excentricitySquared);  // DoubleDouble.sqrt() does not make any difference here.
+        eccentricitySquared = initializer.eccentricitySquared.value;
+        eccentricity        = sqrt(eccentricitySquared);  // DoubleDouble.sqrt() does not make any difference here.
         inverse             = new Inverse();
     }
 
@@ -433,8 +433,8 @@ public abstract class NormalizedProjecti
      */
     NormalizedProjection(final NormalizedProjection other) {
         context             = other.context;
-        excentricity        = other.excentricity;
-        excentricitySquared = other.excentricitySquared;
+        eccentricity        = other.eccentricity;
+        eccentricitySquared = other.eccentricitySquared;
         inverse             = new Inverse();
     }
 
@@ -546,7 +546,7 @@ public abstract class NormalizedProjecti
 
     /**
      * Returns a copy of non-linear internal parameter values of this {@code NormalizedProjection}.
-     * The returned group contains at least the {@link #excentricity} parameter value.
+     * The returned group contains at least the {@link #eccentricity} parameter value.
      * Some subclasses add more non-linear parameters, but most of them do not because many parameters
      * like the <cite>scale factor</cite> or the <cite>false easting/northing</cite> are handled by the
      * {@linkplain ContextualParameters#getMatrix (de)normalization affine transforms} instead.
@@ -563,7 +563,7 @@ public abstract class NormalizedProjecti
     @Override
     public ParameterValueGroup getParameterValues() {
         final ParameterValueGroup group = getParameterDescriptors().createValue();
-        group.parameter("excentricity").setValue(excentricity);
+        group.parameter("eccentricity").setValue(eccentricity);
         final String[] names  = getInternalParameterNames();
         final double[] values = getInternalParameterValues();
         for (int i=0; i<names.length; i++) {
@@ -574,7 +574,7 @@ public abstract class NormalizedProjecti
 
     /**
      * Returns a description of the non-linear internal parameters of this {@code NormalizedProjection}.
-     * The returned group contains at least a descriptor for the {@link #excentricity} parameter.
+     * The returned group contains at least a descriptor for the {@link #eccentricity} parameter.
      * Subclasses may add more parameters.
      *
      * <p>This method is for inspecting the parameter values of this non-linear kernel only,
@@ -600,7 +600,7 @@ public abstract class NormalizedProjecti
                 }
                 final String[] names = getInternalParameterNames();
                 final ParameterDescriptor<?>[] parameters = new ParameterDescriptor<?>[names.length + 1];
-                parameters[0] = MapProjection.EXCENTRICITY;
+                parameters[0] = MapProjection.ECCENTRICITY;
                 for (int i=1; i<parameters.length; i++) {
                     parameters[i] = builder.addName(names[i-1]).create(Double.class, null);
                 }
@@ -612,7 +612,7 @@ public abstract class NormalizedProjecti
     }
 
     /**
-     * Returns the names of any additional internal parameters (other than {@link #excentricity})
+     * Returns the names of any additional internal parameters (other than {@link #eccentricity})
      * that this projection has. The length of this array must be the same than the length of the
      * {@link #getInternalParameterValues()} array, if the later is non-null.
      */
@@ -621,7 +621,7 @@ public abstract class NormalizedProjecti
     }
 
     /**
-     * Returns the values of any additional internal parameters (other than {@link #excentricity}) that
+     * Returns the values of any additional internal parameters (other than {@link #eccentricity}) that
      * this projection has. Those values are also compared by {@link #equals(Object, ComparisonMode)}.
      */
     double[] getInternalParameterValues() {
@@ -757,7 +757,7 @@ public abstract class NormalizedProjecti
      */
     @Override
     protected int computeHashCode() {
-        long c = Double.doubleToLongBits(excentricity);
+        long c = Double.doubleToLongBits(eccentricity);
         final double[] parameters = getInternalParameterValues();
         if (parameters != null) {
             for (int i=0; i<parameters.length; i++) {
@@ -769,7 +769,7 @@ public abstract class NormalizedProjecti
 
     /**
      * Compares the given object with this transform for equivalence. The default implementation checks if
-     * {@code object} is an instance of the same class than {@code this}, then compares the excentricity.
+     * {@code object} is an instance of the same class than {@code this}, then compares the eccentricity.
      *
      * <p>If this method returns {@code true}, then for any given identical source position, the two compared map
      * projections shall compute the same target position. Many of the {@linkplain #getContextualParameters()
@@ -804,23 +804,23 @@ public abstract class NormalizedProjecti
                 if (!Objects.equals(context, that.context)) {
                     return false;
                 }
-                // Fall through for comparing the excentricity.
+                // Fall through for comparing the eccentricity.
             }
             case IGNORE_METADATA: {
                 /*
-                 * There is no need to compare both 'excentricity' and 'excentricitySquared' since the former
-                 * is computed from the later. We are better to compare 'excentricitySquared' since it is the
+                 * There is no need to compare both 'eccentricity' and 'eccentricitySquared' since the former
+                 * is computed from the later. We are better to compare 'eccentricitySquared' since it is the
                  * original value from which the other value is derived.
                  */
-                if (!Numerics.equals(excentricitySquared, that.excentricitySquared)) {
+                if (!Numerics.equals(eccentricitySquared, that.eccentricitySquared)) {
                     return false;
                 }
                 break;
             }
             default: {
                 /*
-                 * We want to compare the excentricity with a tolerance threshold corresponding approximatively
-                 * to an error of 1 cm on Earth. The excentricity for an ellipsoid of semi-major axis a=1 is:
+                 * We want to compare the eccentricity with a tolerance threshold corresponding approximatively
+                 * to an error of 1 cm on Earth. The eccentricity for an ellipsoid of semi-major axis a=1 is:
                  *
                  *     ℯ² = 1 - b²
                  *
@@ -838,12 +838,12 @@ public abstract class NormalizedProjecti
                  *     ε′  ≈   ε⋅(ℯ - 1/ℯ)
                  *
                  * Note that  ε′  is negative for  ℯ < 1  so we actually need to compute  ε⋅(1/ℯ - ℯ)  instead.
-                 * The result is less than 2E-8 for the excentricity of the Earth.
+                 * The result is less than 2E-8 for the eccentricity of the Earth.
                  */
-                final double e = max(excentricity, that.excentricity);
-                if (!Numerics.epsilonEqual(excentricity, that.excentricity, ANGULAR_TOLERANCE * (1/e - e))) {
+                final double e = max(eccentricity, that.eccentricity);
+                if (!Numerics.epsilonEqual(eccentricity, that.eccentricity, ANGULAR_TOLERANCE * (1/e - e))) {
                     assert (mode != ComparisonMode.DEBUG) : Numerics.messageForDifference(
-                            "excentricity", excentricity, that.excentricity);
+                            "eccentricity", eccentricity, that.eccentricity);
                     return false;
                 }
                 break;

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ObliqueStereographic.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ObliqueStereographic.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ObliqueStereographic.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/ObliqueStereographic.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -126,14 +126,14 @@ public class ObliqueStereographic extend
         super(initializer);
         final double φ0     = toRadians(initializer.getAndStore(LATITUDE_OF_ORIGIN));
         final double sinφ0  = sin(φ0);
-        final double ℯsinφ0 = excentricity * sinφ0;
-        n = sqrt(1 + ((excentricitySquared * pow(cos(φ0), 4)) / (1 - excentricitySquared)));
+        final double ℯsinφ0 = eccentricity * sinφ0;
+        n = sqrt(1 + ((eccentricitySquared * pow(cos(φ0), 4)) / (1 - eccentricitySquared)));
         /*
          * Following variables use upper-case because they are written that way in the EPSG guide.
          */
         final double S1 = (1 +  sinφ0) / (1 -  sinφ0);
         final double S2 = (1 - ℯsinφ0) / (1 + ℯsinφ0);
-        final double w1 = pow(S1 * pow(S2, excentricity), n);
+        final double w1 = pow(S1 * pow(S2, eccentricity), n);
         /*
          * The χ₁ variable below was named χ₀ in the EPSG guide. We use the χ₁ name in order to avoid confusion with
          * the conformal latitude of origin, which is also named χ₀ in the EPSG guide. Mathematically, χ₀ and χ₁ are
@@ -191,7 +191,7 @@ public class ObliqueStereographic extend
      * comparing two {@code ObliqueStereographic} projections or formatting them in debug mode.
      *
      * <p>We could report any of the internal parameters. But since they are all derived from φ₀ and
-     * the {@linkplain #excentricity excentricity} and since the excentricity is already reported by
+     * the {@linkplain #eccentricity eccentricity} and since the eccentricity is already reported by
      * the super-class, we report only χ₀ is a representative of the internal parameters.</p>
      */
     @Override
@@ -234,7 +234,7 @@ public class ObliqueStereographic extend
             }
         }
         ObliqueStereographic kernel = this;
-        if (excentricity == 0) {
+        if (eccentricity == 0) {
             kernel = new Spherical(this);
         }
         return context.completeTransform(factory, kernel);
@@ -256,10 +256,10 @@ public class ObliqueStereographic extend
         final double Λ     = srcPts[srcOff  ];      // Λ = λ⋅n  (see below), ignoring longitude of origin.
         final double φ     = srcPts[srcOff+1];
         final double sinφ  = sin(φ);
-        final double ℯsinφ = excentricity * sinφ;
+        final double ℯsinφ = eccentricity * sinφ;
         final double Sa    = (1 +  sinφ) / (1 -  sinφ);
         final double Sb    = (1 - ℯsinφ) / (1 + ℯsinφ);
-        final double w     = c * pow(Sa * pow(Sb, excentricity), n);
+        final double w     = c * pow(Sa * pow(Sb, eccentricity), n);
         /*
          * Convert the geodetic coordinates (φ,λ) to conformal coordinates (χ,Λ) before to apply the
          * actual stereographic projection.  The geodetic and conformal coordinates will be the same
@@ -305,7 +305,7 @@ public class ObliqueStereographic extend
          *      ∂w/∂φ =  2⋅n⋅w⋅(1/cosφ - ℯ²⋅cosφ/(1 - ℯ²⋅sin²φ));
          */
         final double cosφ = cos(φ);
-        final double dχ_dφ = (1/cosφ - cosφ*excentricitySquared/(1 - ℯsinφ*ℯsinφ)) * 2*n*sqrt(w) / (w + 1);
+        final double dχ_dφ = (1/cosφ - cosφ*eccentricitySquared/(1 - ℯsinφ*ℯsinφ)) * 2*n*sqrt(w) / (w + 1);
         /*
          * Above ∂χ/∂φ is equals to 1 in the spherical case.
          * Remaining formulas below are the same than in the spherical case.
@@ -351,10 +351,10 @@ public class ObliqueStereographic extend
         final double sinχ = sin(χ0 + 2*atan(y - x*tan(j/2)));
         final double ψ = log((1 + sinχ) / ((1 - sinχ)*c)) / (2*n);
         double φ = 2*atan(exp(ψ)) - PI/2;                               // First approximation
-        final double he = excentricity/2;
-        final double me = 1 - excentricitySquared;
+        final double he = eccentricity/2;
+        final double me = 1 - eccentricitySquared;
         for (int it=0; it<MAXIMUM_ITERATIONS; it++) {
-            final double ℯsinφ = excentricity * sin(φ);
+            final double ℯsinφ = eccentricity * sin(φ);
             final double ψi = log(tan(φ/2 + PI/4) * pow((1 - ℯsinφ) / (1 + ℯsinφ), he));
             final double Δφ = (ψ - ψi) * cos(φ) * (1 - ℯsinφ*ℯsinφ) / me;
             φ += Δφ;
@@ -372,7 +372,7 @@ public class ObliqueStereographic extend
 
     /**
      * Provides the transform equations for the spherical case of the Oblique Stereographic projection.
-     * This implementation can be used when {@link #excentricity} = 0.
+     * This implementation can be used when {@link #eccentricity} = 0.
      *
      * @author  Rémi Maréchal (Geomatys)
      * @author  Martin Desruisseaux (Geomatys)

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/PolarStereographic.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/PolarStereographic.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/PolarStereographic.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/PolarStereographic.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -207,7 +207,7 @@ public class PolarStereographic extends
              *
              * In the spherical case, should give ρ == 2.
              */
-            ρ = verbatim(2 / sqrt(pow(1+excentricity, 1+excentricity) * pow(1-excentricity, 1-excentricity)));
+            ρ = verbatim(2 / sqrt(pow(1+eccentricity, 1+eccentricity) * pow(1-eccentricity, 1-eccentricity)));
             ρF = null;
         } else {
             /*
@@ -229,7 +229,7 @@ public class PolarStereographic extends
              */
             final double sinφ1 = sin(φ1);
             final double mF = initializer.scaleAtφ(sinφ1, cos(φ1));
-            ρ = verbatim(mF / expOfNorthing(φ1, excentricity*sinφ1));
+            ρ = verbatim(mF / expOfNorthing(φ1, eccentricity*sinφ1));
             ρF = (variant == C) ? verbatim(-mF) : null;
         }
         /*
@@ -269,7 +269,7 @@ public class PolarStereographic extends
     @Override
     public MathTransform createMapProjection(final MathTransformFactory factory) throws FactoryException {
         PolarStereographic kernel = this;
-        if (excentricity == 0) {
+        if (eccentricity == 0) {
             kernel = new Spherical(this);
         }
         return context.completeTransform(factory, kernel);
@@ -304,7 +304,7 @@ public class PolarStereographic extends
          * The next step is to compute ρ = 2⋅a⋅k₀⋅t / …, but those steps are
          * applied by the denormalization matrix and shall not be done here.
          */
-        final double t = expOfNorthing(φ, excentricity*sinφ);
+        final double t = expOfNorthing(φ, eccentricity*sinφ);
         final double x = t * sinθ;
         final double y = t * cosθ;
         if (dstPts != null) {

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/TransverseMercator.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/TransverseMercator.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/TransverseMercator.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/TransverseMercator.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -73,7 +73,7 @@ public class TransverseMercator extends
 
     /**
      * Coefficients in the series expansion of the forward projection,
-     * depending only on {@linkplain #excentricity excentricity} value.
+     * depending only on {@linkplain #eccentricity eccentricity} value.
      * The series expansion is of the following form:
      *
      *     <blockquote>cf₂⋅f(2θ) + cf₄⋅f(4θ) + cf₆⋅f(6θ) + cf₈⋅f(8θ)</blockquote>
@@ -164,7 +164,7 @@ public class TransverseMercator extends
          * NOTE: the EPSG documentation makes special cases for φ₀ = 0 or ±π/2. This is not
          * needed here; we verified that the code below produces naturally the expected values.
          */
-        final double Q = asinh(tan(φ0)) - excentricity * atanh(excentricity * sin(φ0));
+        final double Q = asinh(tan(φ0)) - eccentricity * atanh(eccentricity * sin(φ0));
         final double β = atan(sinh(Q));
         final DoubleDouble M0 = new DoubleDouble();
         M0.value = cf8 * sin(8*β)
@@ -216,7 +216,7 @@ public class TransverseMercator extends
          * 'n' value at serialization time.
          */
         final DoubleDouble t = new DoubleDouble(1, 0);
-        t.subtract(excentricitySquared, 0);
+        t.subtract(eccentricitySquared, 0);
         t.sqrt();
         t.ratio_1m_1p();
         computeCoefficients(t.doubleValue());
@@ -240,7 +240,7 @@ public class TransverseMercator extends
      *
      * As much as possible, b/a should be computed from the map projection parameters.
      * However if those parameters are not available anymore, then they can be computed
-     * from the excentricity as:
+     * from the eccentricity as:
      *
      *     <blockquote>b/a = √(1 - ℯ²)</blockquote>
      *
@@ -294,7 +294,7 @@ public class TransverseMercator extends
     @Override
     public MathTransform createMapProjection(final MathTransformFactory factory) throws FactoryException {
         TransverseMercator kernel = this;
-        if (excentricity == 0) {
+        if (eccentricity == 0) {
             kernel = new Spherical(this);
         }
         return context.completeTransform(factory, kernel);
@@ -316,8 +316,8 @@ public class TransverseMercator extends
         final double λ     = srcPts[srcOff  ];
         final double φ     = srcPts[srcOff+1];
         final double sinλ  = sin(λ);
-        final double ℯsinφ = sin(φ) * excentricity;
-        final double Q     = asinh(tan(φ)) - atanh(ℯsinφ) * excentricity;
+        final double ℯsinφ = sin(φ) * eccentricity;
+        final double Q     = asinh(tan(φ)) - atanh(ℯsinφ) * eccentricity;
         final double coshQ = cosh(Q);
         final double η0    = atanh(sinλ / coshQ);
         /*
@@ -418,7 +418,7 @@ public class TransverseMercator extends
         final double sqrt1_thQchη0 = sqrt(1 - (tanhQ * tanhQ) * (coshη0 * coshη0)); //-- Qη0
 
         //-- dQ_dλ = 0;
-        final double dQ_dφ  = 1 / cosφ - excentricitySquared * cosφ / (1 - ℯsinφ * ℯsinφ);
+        final double dQ_dφ  = 1 / cosφ - eccentricitySquared * cosφ / (1 - ℯsinφ * ℯsinφ);
 
         final double dη0_dλ =   cosλ * coshQ         / cosh2Q_sin2λ;
         final double dη0_dφ = - dQ_dφ * sinλ * sinhQ / cosh2Q_sin2λ;
@@ -544,10 +544,10 @@ public class TransverseMercator extends
          * Following usually converges in 4 iterations.
          * The first iteration is unrolled.
          */
-        double p = excentricity * atanh(excentricity * tanh(Q));
+        double p = eccentricity * atanh(eccentricity * tanh(Q));
         double Qp = Q + p;
         for (int it=0; it<MAXIMUM_ITERATIONS; it++) {
-            final double c = excentricity * atanh(excentricity * tanh(Qp));
+            final double c = eccentricity * atanh(eccentricity * tanh(Qp));
             Qp = Q + c;
             if (abs(c - p) <= ITERATION_TOLERANCE) {
                 dstPts[dstOff  ] = asin(tanh(η0) / cos(β));

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -555,7 +555,7 @@ public class DefaultMathTransformFactory
              * NormalizedProjection class (our base class for all map projection implementations)
              * to known that the ellipsoid definitive parameter is the inverse flattening factor
              * instead than the semi-major axis length. It makes a small difference in the accuracy
-             * of the excentricity parameter.
+             * of the eccentricity parameter.
              */
             if (isIvfDefinitive) try {
                 parameters.parameter(Constants.INVERSE_FLATTENING).setValue(ellipsoid.getInverseFlattening());

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/EllipsoidalToCartesianTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/EllipsoidalToCartesianTransform.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/EllipsoidalToCartesianTransform.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/EllipsoidalToCartesianTransform.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -54,7 +54,7 @@ import org.apache.sis.util.resources.Err
 import static java.lang.Math.*;
 import static org.apache.sis.internal.referencing.provider.MapProjection.SEMI_MAJOR;
 import static org.apache.sis.internal.referencing.provider.MapProjection.SEMI_MINOR;
-import static org.apache.sis.internal.referencing.provider.MapProjection.EXCENTRICITY;
+import static org.apache.sis.internal.referencing.provider.MapProjection.ECCENTRICITY;
 import static org.apache.sis.internal.referencing.provider.GeocentricAffineBetweenGeographic.DIMENSION;
 
 
@@ -107,26 +107,26 @@ public class EllipsoidalToCartesianTrans
     private static ParameterDescriptorGroup DESCRIPTOR;
 
     /**
-     * Minimal excentricity value before to consider that the approximated φ value should be made more accurate
-     * by the use of an iterative method. The iterative method is not needed for a planet of Earth excentricity,
-     * but become useful for planets of higher excentricity.
+     * Minimal eccentricity value before to consider that the approximated φ value should be made more accurate
+     * by the use of an iterative method. The iterative method is not needed for a planet of Earth eccentricity,
+     * but become useful for planets of higher eccentricity.
      *
-     * <p>Actually the need for iteration is not just a matter of excentricity. It is also a matter of
-     * <var>h</var> values. But empirical tests suggest that with Earth's excentricity (about 0.082),
+     * <p>Actually the need for iteration is not just a matter of eccentricity. It is also a matter of
+     * <var>h</var> values. But empirical tests suggest that with Earth's eccentricity (about 0.082),
      * the limit for <var>h</var> is quite high (close to 2000 km for a point at 30°N). This limit is
-     * reduced to about 200 km for an excentricity of 0.16. It may be possible to find a formula for
+     * reduced to about 200 km for an eccentricity of 0.16. It may be possible to find a formula for
      * the limit of <var>h</var> as a function of ℯ and φ, but this has not been explored yet.</p>
      *
-     * @see org.apache.sis.referencing.operation.projection.ConformalProjection#EXCENTRICITY_THRESHOLD
+     * @see org.apache.sis.referencing.operation.projection.ConformalProjection#ECCENTRICITY_THRESHOLD
      */
-    private static final double EXCENTRICITY_THRESHOLD = 0.16;
+    private static final double ECCENTRICITY_THRESHOLD = 0.16;
 
     /**
-     * The square of excentricity: ℯ² = (a²-b²)/a² where
+     * The square of eccentricity: ℯ² = (a²-b²)/a² where
      * <var>a</var> is the <cite>semi-major</cite> axis length and
      * <var>b</var> is the <cite>semi-minor</cite> axis length.
      */
-    protected final double excentricitySquared;
+    protected final double eccentricitySquared;
 
     /**
      * The b/a ratio where
@@ -136,7 +136,7 @@ public class EllipsoidalToCartesianTrans
      * (because of the work performed by the normalization matrices), we just drop <var>a</var>
      * in the formulas - so this field can be written as just <var>b</var>.
      *
-     * <p>This value is related to {@link #excentricitySquared} and to the ε value used in EPSG guide
+     * <p>This value is related to {@link #eccentricitySquared} and to the ε value used in EPSG guide
      * by (assuming a=1):</p>
      * <ul>
      *   <li>ℯ² = 1 - b²</li>
@@ -145,14 +145,14 @@ public class EllipsoidalToCartesianTrans
      *
      * <p><strong>Consider this field as final!</strong>
      * It is not final only for the purpose of {@link #readObject(ObjectInputStream)}.
-     * This field is recomputed from {@link #excentricitySquared} on deserialization.</p>
+     * This field is recomputed from {@link #eccentricitySquared} on deserialization.</p>
      */
     private transient double b;
 
     /**
      * Whether calculation of φ should use an iterative method after the first φ approximation.
-     * The current implementation sets this field to {@code true} at construction time when the excentricity value
-     * is greater than or equals to {@link #EXCENTRICITY_THRESHOLD}, but this policy may change in any future SIS
+     * The current implementation sets this field to {@code true} at construction time when the eccentricity value
+     * is greater than or equals to {@link #ECCENTRICITY_THRESHOLD}, but this policy may change in any future SIS
      * version (for example we do not take the <var>h</var> values in account yet).
      *
      * <p><strong>Consider this field as final!</strong>
@@ -239,8 +239,8 @@ public class EllipsoidalToCartesianTrans
         ArgumentChecks.ensureStrictlyPositive("semiMajor", semiMajor);
         ArgumentChecks.ensureStrictlyPositive("semiMinor", semiMinor);
         b = semiMinor / semiMajor;
-        excentricitySquared = 1 - (b * b);
-        useIterations = (excentricitySquared >= EXCENTRICITY_THRESHOLD * EXCENTRICITY_THRESHOLD);
+        eccentricitySquared = 1 - (b * b);
+        useIterations = (eccentricitySquared >= ECCENTRICITY_THRESHOLD * ECCENTRICITY_THRESHOLD);
         this.withHeight = withHeight;
         /*
          * Copy parameters to the ContextualParameter. Those parameters are not used directly
@@ -277,8 +277,8 @@ public class EllipsoidalToCartesianTrans
      */
     private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
-        useIterations = (excentricitySquared >= EXCENTRICITY_THRESHOLD * EXCENTRICITY_THRESHOLD);
-        b = sqrt(1 - excentricitySquared);
+        useIterations = (eccentricitySquared >= ECCENTRICITY_THRESHOLD * ECCENTRICITY_THRESHOLD);
+        b = sqrt(1 - eccentricitySquared);
     }
 
     /**
@@ -333,7 +333,7 @@ public class EllipsoidalToCartesianTrans
 
     /**
      * Returns a copy of internal parameter values of this {@code EllipsoidalToCartesianTransform} transform.
-     * The returned group contains parameter values for the number of dimensions and the excentricity.
+     * The returned group contains parameter values for the number of dimensions and the eccentricity.
      *
      * <div class="note"><b>Note:</b>
      * this method is mostly for {@linkplain org.apache.sis.io.wkt.Convention#INTERNAL debugging purposes}
@@ -347,14 +347,14 @@ public class EllipsoidalToCartesianTrans
     @Override
     public ParameterValueGroup getParameterValues() {
         final Parameters pg = Parameters.castOrWrap(getParameterDescriptors().createValue());
-        pg.getOrCreate(EXCENTRICITY).setValue(sqrt(excentricitySquared));
+        pg.getOrCreate(ECCENTRICITY).setValue(sqrt(eccentricitySquared));
         pg.getOrCreate(DIMENSION).setValue(getSourceDimensions());
         return pg;
     }
 
     /**
      * Returns a description of the internal parameters of this {@code EllipsoidalToCartesianTransform} transform.
-     * The returned group contains parameter descriptors for the number of dimensions and the excentricity.
+     * The returned group contains parameter descriptors for the number of dimensions and the eccentricity.
      *
      * @return A description of the internal parameters.
      */
@@ -364,7 +364,7 @@ public class EllipsoidalToCartesianTrans
         synchronized (EllipsoidalToCartesianTransform.class) {
             if (DESCRIPTOR == null) {
                 DESCRIPTOR = new ParameterBuilder().setCodeSpace(Citations.SIS, Constants.SIS)
-                        .addName("Ellipsoidal to Cartesian").createGroup(1, 1, DIMENSION, EXCENTRICITY);
+                        .addName("Ellipsoidal to Cartesian").createGroup(1, 1, DIMENSION, ECCENTRICITY);
             }
             return DESCRIPTOR;
         }
@@ -451,10 +451,10 @@ public class EllipsoidalToCartesianTrans
         final double sinλ = sin(λ);
         final double cosφ = cos(φ);
         final double sinφ = sin(φ);
-        final double ν2   = 1 / (1 - excentricitySquared*(sinφ*sinφ));   // Square of ν (see below)
+        final double ν2   = 1 / (1 - eccentricitySquared*(sinφ*sinφ));   // Square of ν (see below)
         final double ν    = sqrt(ν2);                                    // Prime vertical radius of curvature at latitude φ
         final double r    = ν + h;
-        final double νℯ   = ν * (1 - excentricitySquared);
+        final double νℯ   = ν * (1 - eccentricitySquared);
         if (dstPts != null) {
             final double rcosφ = r * cosφ;
             dstPts[dstOff  ] = rcosφ  * cosλ;                            // X: Toward prime meridian
@@ -523,11 +523,11 @@ public class EllipsoidalToCartesianTrans
             final double φ     = srcPts[srcOff++];                                 // Latitude
             final double h     = withHeight ? srcPts[srcOff++] : 0;                // Height above the ellipsoid
             final double sinφ  = sin(φ);
-            final double ν     = 1/sqrt(1 - excentricitySquared * (sinφ*sinφ));    // Prime vertical radius of curvature at latitude φ
+            final double ν     = 1/sqrt(1 - eccentricitySquared * (sinφ*sinφ));    // Prime vertical radius of curvature at latitude φ
             final double rcosφ = (ν + h) * cos(φ);
             dstPts[dstOff++]   = rcosφ * cos(λ);                                   // X: Toward prime meridian
             dstPts[dstOff++]   = rcosφ * sin(λ);                                   // Y: Toward 90° east
-            dstPts[dstOff++]   = (ν * (1 - excentricitySquared) + h) * sinφ;       // Z: Toward north pole
+            dstPts[dstOff++]   = (ν * (1 - eccentricitySquared) + h) * sinφ;       // Z: Toward north pole
             srcOff += srcInc;
             dstOff += dstInc;
         }
@@ -594,11 +594,11 @@ next:   while (--numPts >= 0) {
             final double tanq  = Z / (p*b);
             final double cos2q = 1/(1 + tanq*tanq);
             final double sin2q = 1 - cos2q;
-            double φ = atan((Z + copySign(excentricitySquared * sin2q*sqrt(sin2q), tanq) / b) /
-                            (p -          excentricitySquared * cos2q*sqrt(cos2q)));
+            double φ = atan((Z + copySign(eccentricitySquared * sin2q*sqrt(sin2q), tanq) / b) /
+                            (p -          eccentricitySquared * cos2q*sqrt(cos2q)));
             /*
              * The above is an approximation of φ. Usually we are done with a good approximation for
-             * a planet of the excentricity of Earth. Code below is the one that will be executed in
+             * a planet of the eccentricity of Earth. Code below is the one that will be executed in
              * the vast majority of cases.
              */
             if (!useIterations) {
@@ -606,20 +606,20 @@ next:   while (--numPts >= 0) {
                 dstPts[dstOff++] = φ;
                 if (withHeight) {
                     final double sinφ = sin(φ);
-                    final double ν = 1/sqrt(1 - excentricitySquared * (sinφ*sinφ));
+                    final double ν = 1/sqrt(1 - eccentricitySquared * (sinφ*sinφ));
                     dstPts[dstOff++] = p/cos(φ) - ν;
                 }
                 srcOff += srcInc;
                 dstOff += dstInc;
             } else {
                 /*
-                 * If this code is used on a planet with high excentricity,
+                 * If this code is used on a planet with high eccentricity,
                  * the φ value may need to be improved by an iterative method.
                  */
                 for (int it=0; it<Formulas.MAXIMUM_ITERATIONS; it++) {
                     final double sinφ = sin(φ);
-                    final double ν = 1/sqrt(1 - excentricitySquared * (sinφ*sinφ));
-                    final double Δφ = φ - (φ = atan((Z + excentricitySquared * ν * sinφ) / p));
+                    final double ν = 1/sqrt(1 - eccentricitySquared * (sinφ*sinφ));
+                    final double Δφ = φ - (φ = atan((Z + eccentricitySquared * ν * sinφ) / p));
                     if (!(abs(Δφ) >= Formulas.ANGULAR_TOLERANCE * (PI/180) * 0.25)) {   // Use ! for accepting NaN.
                         dstPts[dstOff++] = atan2(Y, X);
                         dstPts[dstOff++] = φ;

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -152,14 +152,14 @@ public class MolodenskyTransform extends
     private final double semiMajor;
 
     /**
-     * The square of excentricity of the source ellipsoid.
+     * The square of eccentricity of the source ellipsoid.
      * This can be computed by ℯ² = (a²-b²)/a² where
      * <var>a</var> is the <cite>semi-major</cite> axis length and
      * <var>b</var> is the <cite>semi-minor</cite> axis length.
      *
      * @see DefaultEllipsoid#getEccentricitySquared()
      */
-    private final double excentricitySquared;
+    private final double eccentricitySquared;
 
     /**
      * Difference in the semi-major axes of the target and source ellipsoids: {@code Δa = target a - source a}.
@@ -252,7 +252,7 @@ public class MolodenskyTransform extends
 
         final double semiMinor = src.getSemiMinorAxis();
         final double Δf = src.flatteningDifference(target);
-        excentricitySquared = src.getEccentricitySquared();
+        eccentricitySquared = src.getEccentricitySquared();
         Δfmod = isAbridged ? (semiMajor * Δf) + (semiMajor - semiMinor) * (Δa / semiMajor)
                            : (semiMinor * Δf);
         /*
@@ -364,7 +364,7 @@ public class MolodenskyTransform extends
 
     /**
      * Returns a copy of internal parameter values of this {@code MolodenskyTransform}.
-     * The returned group contains parameter values for the excentricity and the shift among others.
+     * The returned group contains parameter values for the eccentricity and the shift among others.
      *
      * <div class="note"><b>Note:</b>
      * this method is mostly for {@linkplain org.apache.sis.io.wkt.Convention#INTERNAL debugging purposes}
@@ -381,14 +381,14 @@ public class MolodenskyTransform extends
         final Unit<?> unit = getLinearUnit();
         setEPSG(pg, unit, context.doubleValue(Molodensky.FLATTENING_DIFFERENCE));
         pg.getOrCreate(Molodensky.SRC_SEMI_MAJOR).setValue(semiMajor, unit);
-        pg.getOrCreate(MapProjection.EXCENTRICITY).setValue(sqrt(excentricitySquared));
+        pg.getOrCreate(MapProjection.ECCENTRICITY).setValue(sqrt(eccentricitySquared));
         pg.parameter("abridged").setValue(isAbridged);
         return pg;
     }
 
     /**
      * Returns a description of the internal parameters of this {@code MolodenskyTransform} transform.
-     * The returned group contains parameter descriptors for the number of dimensions and the excentricity.
+     * The returned group contains parameter descriptors for the number of dimensions and the eccentricity.
      *
      * @return A description of the internal parameters.
      */
@@ -517,17 +517,17 @@ public class MolodenskyTransform extends
         final double sinφ  = sin(φ);
         final double cosφ  = cos(φ);
         final double sin2φ = sinφ * sinφ;
-        final double ν2den = 1 - excentricitySquared*sin2φ;                 // Square of the denominator of ν
+        final double ν2den = 1 - eccentricitySquared*sin2φ;                 // Square of the denominator of ν
         final double νden  = sqrt(ν2den);                                   // Denominator of ν
         final double ρden  = ν2den * νden;                                  // Denominator of ρ
-        double ρ = semiMajor * (1 - excentricitySquared) / ρden;            // Other notation: Rm = ρ
+        double ρ = semiMajor * (1 - eccentricitySquared) / ρden;            // Other notation: Rm = ρ
         double ν = semiMajor / νden;                                        // Other notation: Rn = ν
         double t = Δfmod * 2;                                               // A term in the calculation of Δφ
         if (!isAbridged) {
             ρ += h;
             ν += h;
             t = t*(0.5/νden + 0.5/ρden)                 // = Δf⋅[ν⋅(b/a) + ρ⋅(a/b)]     (without the +h in ν and ρ)
-                    + Δa*excentricitySquared/νden;      // = Δa⋅[ℯ²⋅ν/a]
+                    + Δa*eccentricitySquared/νden;      // = Δa⋅[ℯ²⋅ν/a]
         }
         final double spcλ = tY*sinλ + tX*cosλ;                      // "spc" stands for "sin plus cos"
         final double cmsλ = tY*cosλ - tX*sinλ;                      // "cms" stands for "cos minus sin"
@@ -557,8 +557,8 @@ public class MolodenskyTransform extends
          */
         final Matrix matrix   = Matrices.createDiagonal(getTargetDimensions(), getSourceDimensions());
         final double sinφcosφ = sinφ * cosφ;
-        final double dν       = excentricitySquared*sinφcosφ / ν2den;
-        final double dν3ρ     = 3*dν * (1 - excentricitySquared) / ν2den;
+        final double dν       = eccentricitySquared*sinφcosφ / ν2den;
+        final double dν3ρ     = 3*dν * (1 - eccentricitySquared) / ν2den;
         //    double dXdλ     = spcλ;
         final double dYdλ     = cmsλ * sinφ;
         final double dZdλ     = cmsλ * cosφ;
@@ -584,8 +584,8 @@ public class MolodenskyTransform extends
              */
             final double dρ = dν3ρ * νden * (semiMajor / ρ);    // Reminder: that ρ contains a h term.
             dXdφ -= dν * cmsλ * semiMajor / (νden*ν);           // Reminder: that ν contains a h term.
-            dYdφ -= dρ * dZdφ - (Δfmod*(dν*2/(1 - excentricitySquared) + (1 + 1/ν2den)*(dν - dρ))
-                                  + Δa*(dν + 1)*excentricitySquared) * sinφcosφ / νden;
+            dYdφ -= dρ * dZdφ - (Δfmod*(dν*2/(1 - eccentricitySquared) + (1 + 1/ν2den)*(dν - dρ))
+                                  + Δa*(dν + 1)*eccentricitySquared) * sinφcosφ / νden;
             if (isSource3D) {
                 final double dXdh =  cmsλ / ν;
                 final double dYdh = -cmsφ / ρ;
@@ -663,15 +663,15 @@ public class MolodenskyTransform extends
             final double sinφ  = sin(φ);
             final double cosφ  = cos(φ);
             final double sin2φ = sinφ * sinφ;
-                  double ρden  = 1 - excentricitySquared * sin2φ;               // Denominator of ρ (completed later)
+                  double ρden  = 1 - eccentricitySquared * sin2φ;               // Denominator of ρ (completed later)
             final double νden  = sqrt(ρden);                                    // Denominator of ν
-            double ρ = semiMajor * (1 - excentricitySquared) / (ρden *= νden);  // (also complete calculation of ρden)
+            double ρ = semiMajor * (1 - eccentricitySquared) / (ρden *= νden);  // (also complete calculation of ρden)
             double ν = semiMajor / νden;                                        // Other notation: Rm = ρ and Rn = ν
             double t = Δfmod * 2;                                               // A term in the calculation of Δφ
             if (!isAbridged) {
                 ρ += h;
                 ν += h;
-                t = t*(0.5/νden + 0.5/ρden) + Δa*excentricitySquared/νden;
+                t = t*(0.5/νden + 0.5/ρden) + Δa*eccentricitySquared/νden;
             }
             final double spcλ = tY*sinλ + tX*cosλ;
             dstPts[dstOff++] = λ + ANGULAR_SCALE * (tY*cosλ - tX*sinλ) / (ν*cosφ);
@@ -755,7 +755,7 @@ public class MolodenskyTransform extends
                 && Numerics.equals(Δa,                  that.Δa)
                 && Numerics.equals(Δfmod,               that.Δfmod)
                 && Numerics.equals(semiMajor,           that.semiMajor)
-                && Numerics.equals(excentricitySquared, that.excentricitySquared);
+                && Numerics.equals(eccentricitySquared, that.eccentricitySquared);
         }
         return false;
     }

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeocentricTranslationTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeocentricTranslationTest.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeocentricTranslationTest.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeocentricTranslationTest.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -235,7 +235,7 @@ public final strictfp class GeocentricTr
                 "    Parameter[“elt_1_1”, 0.017453292519943295],\n" +
                 "    Parameter[“elt_2_2”, 1.567855942887398E-7]],\n" +
                 "  Param_MT[“Ellipsoidal to Cartesian”,\n" +
-                "    Parameter[“excentricity”, 0.08181919084262157],\n" +
+                "    Parameter[“eccentricity”, 0.08181919084262157],\n" +
                 "    Parameter[“dim”, 3]],\n" +
                 "  Param_MT[“Affine”,\n" +
                 "    Parameter[“num_row”, 4],\n" +
@@ -247,7 +247,7 @@ public final strictfp class GeocentricTr
                 "    Parameter[“elt_2_2”, 0.9999606483644456],\n" +
                 "    Parameter[“elt_2_3”, 1.8335353697517302E-5]],\n" +
                 "  Param_MT[“Cartesian to ellipsoidal”,\n" +
-                "    Parameter[“excentricity”, 0.08199188997902956],\n" +
+                "    Parameter[“eccentricity”, 0.08199188997902956],\n" +
                 "    Parameter[“dim”, 3]],\n" +
                 "  Param_MT[“Affine”,\n" +
                 "    Parameter[“num_row”, 4],\n" +

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ConformalProjectionTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ConformalProjectionTest.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ConformalProjectionTest.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/ConformalProjectionTest.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -151,7 +151,7 @@ public final strictfp class ConformalPro
      * @return {@code Math.exp} of the Mercator projection of the given latitude.
      */
     private static double expOfNorthing(final ConformalProjection projection, final double φ) {
-        return projection.expOfNorthing(φ, projection.excentricity * sin(φ));
+        return projection.expOfNorthing(φ, projection.eccentricity * sin(φ));
     }
 
     /**
@@ -297,7 +297,7 @@ public final strictfp class ConformalPro
     @Test
     public void compareWithSeriesExpansion() throws ProjectionException {
         final ConformalProjection projection = new NoOp(true);
-        final MercatorMethodComparison comparator = new MercatorMethodComparison(projection.excentricitySquared);
+        final MercatorMethodComparison comparator = new MercatorMethodComparison(projection.eccentricitySquared);
         final Random random = TestUtilities.createRandomNumberGenerator();
         final int numSamples = 2000;
         for (int i=0; i<numSamples; i++) {

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/LambertConicConformalTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/LambertConicConformalTest.java?rev=1713510&r1=1713509&r2=1713510&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/LambertConicConformalTest.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/LambertConicConformalTest.java [UTF-8] Mon Nov  9 18:55:56 2015
@@ -91,10 +91,10 @@ public final strictfp class LambertConic
 
     /**
      * Tests the WKT formatting of {@link NormalizedProjection}. For the Lambert Conformal projection, we expect
-     * the internal {@code n} parameter in addition to the excentricity.
+     * the internal {@code n} parameter in addition to the eccentricity.
      *
      * <div class="section">Note on accuracy</div>
-     * The value of the excentricity parameter should be fully accurate because it is calculated using only the
+     * The value of the eccentricity parameter should be fully accurate because it is calculated using only the
      * {@link Math#sqrt(double)} function (ignoring basic algebraic operations) which, according javadoc, must
      * give the result closest to the true mathematical result. But the functions involved in the calculation of
      * <var>n</var> do not have such strong guarantees. So we use a regular expression in this test for ignoring
@@ -105,7 +105,7 @@ public final strictfp class LambertConic
         createNormalizedProjection(true, 40);
         assertWktEqualsRegex("(?m)\\Q" +
                 "PARAM_MT[“Lambert conic conformal”,\n" +
-                "  PARAMETER[“excentricity”, 0.0818191908426215],\n" +
+                "  PARAMETER[“eccentricity”, 0.0818191908426215],\n" +
                 "  PARAMETER[“n”, 0.64278760968653\\E\\d*\\]\\]");  // 0.6427876096865393 in the original test.
     }
 
@@ -138,7 +138,7 @@ public final strictfp class LambertConic
         assertEquals ("Inverse -∞", +PI/2, inverseTransform(-INF), NORMALIZED_TOLERANCE);
 
         // Like the north case, but with sign inversed.
-        createNormalizedProjection(((LambertConicConformal) transform).excentricity != 0, -40);
+        createNormalizedProjection(((LambertConicConformal) transform).eccentricity != 0, -40);
         validate();
 
         assertEquals ("Not a number",     NaN, transform(NaN),            NORMALIZED_TOLERANCE);



Mime
View raw message