sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject [sis] 01/03: Replace "ordinate" term by "coordinate" for compliance with ISO 19111 terminology. https://issues.apache.org/jira/browse/SIS-461
Date Tue, 11 Jun 2019 15:13:28 GMT
This is an automated email from the ASF dual-hosted git repository.

desruisseaux pushed a commit to branch geoapi-4.0
in repository https://gitbox.apache.org/repos/asf/sis.git

commit 3ebdf21d34aee52e8231b9e1744521813dc9323b
Author: Martin Desruisseaux <martin.desruisseaux@geomatys.com>
AuthorDate: Tue Jun 11 16:35:57 2019 +0200

    Replace "ordinate" term by "coordinate" for compliance with ISO 19111 terminology.
    https://issues.apache.org/jira/browse/SIS-461
---
 .../org/apache/sis/console/TransformCommand.java   |  18 +-
 .../org/apache/sis/openoffice/Transformer.java     |   4 +-
 .../sis/coverage/grid/GridCoordinatesView.java     |  18 +-
 .../java/org/apache/sis/internal/feature/ESRI.java |   8 +-
 .../apache/sis/internal/feature/Geometries.java    |  18 +-
 .../java/org/apache/sis/internal/feature/JTS.java  |  10 +-
 .../org/apache/sis/internal/feature/Java2D.java    |  14 +-
 .../apache/sis/internal/feature/MovingFeature.java |   4 +-
 .../org/apache/sis/internal/feature/Resources.java |   4 +-
 .../sis/internal/feature/Resources.properties      |   2 +-
 .../sis/internal/feature/Resources_fr.properties   |   2 +-
 .../sis/coverage/grid/GridDerivationTest.java      |   2 +-
 .../sis/internal/metadata/ReferencingServices.java |   4 +-
 .../iso/extent/DefaultGeographicBoundingBox.java   |   4 +-
 .../gazetteer/GeohashReferenceSystem.java          |   4 +-
 .../gazetteer/MilitaryGridReferenceSystem.java     |   4 +-
 .../sis/referencing/gazetteer/SimpleLocation.java  |   8 +-
 .../sis/geometry/AbstractDirectPosition.java       |  59 +++--
 .../org/apache/sis/geometry/AbstractEnvelope.java  |  80 +++---
 .../org/apache/sis/geometry/ArrayEnvelope.java     | 146 +++++------
 .../org/apache/sis/geometry/CoordinateFormat.java  |  56 ++---
 .../org/apache/sis/geometry/CurveExtremum.java     |   8 +-
 .../org/apache/sis/geometry/DirectPosition1D.java  |  50 ++--
 .../org/apache/sis/geometry/DirectPosition2D.java  |  32 +--
 .../java/org/apache/sis/geometry/Envelope2D.java   |  86 +++----
 .../java/org/apache/sis/geometry/Envelopes.java    |  53 ++--
 .../apache/sis/geometry/GeneralDirectPosition.java | 130 +++++-----
 .../org/apache/sis/geometry/GeneralEnvelope.java   | 268 ++++++++++-----------
 .../org/apache/sis/geometry/ImmutableEnvelope.java |  14 +-
 .../java/org/apache/sis/geometry/Shapes2D.java     |  16 +-
 .../java/org/apache/sis/geometry/SubEnvelope.java  |  54 ++---
 .../java/org/apache/sis/geometry/package-info.java |   2 +-
 .../internal/referencing/CoordinateOperations.java |   2 +-
 .../internal/referencing/DirectPositionView.java   |  60 ++---
 .../internal/referencing/EPSGParameterDomain.java  |   2 +-
 .../apache/sis/internal/referencing/Formulas.java  |   6 +-
 .../internal/referencing/PositionTransformer.java  |   2 +-
 .../internal/referencing/ServicesForMetadata.java  |   4 +-
 .../referencing/j2d/IntervalRectangle.java         |  76 +++---
 .../java/org/apache/sis/parameter/Verifier.java    |   2 +-
 .../apache/sis/referencing/cs/AxesConvention.java  |   6 +-
 .../cs/DefaultCoordinateSystemAxis.java            |   8 +-
 .../apache/sis/referencing/cs/DefaultLinearCS.java |   2 +-
 .../org/apache/sis/referencing/cs/Normalizer.java  |   6 +-
 .../sis/referencing/datum/DefaultEllipsoid.java    |   2 +-
 .../referencing/factory/sql/EPSGDataAccess.java    |   2 +-
 .../operation/AbstractCoordinateOperation.java     |   8 +-
 .../operation/CoordinateOperationFinder.java       |   6 +-
 .../operation/DefaultPassThroughOperation.java     |  16 +-
 .../sis/referencing/operation/matrix/Matrices.java |  24 +-
 .../referencing/operation/matrix/MatrixSIS.java    |  18 +-
 .../operation/matrix/NonSquareMatrix.java          |  16 +-
 .../sis/referencing/operation/matrix/Solver.java   |   2 +-
 .../operation/projection/NormalizedProjection.java |   8 +-
 .../operation/projection/package-info.java         |   2 +-
 .../operation/transform/AbstractMathTransform.java |  30 +--
 .../transform/AbstractMathTransform1D.java         |  28 +--
 .../operation/transform/ContextualParameters.java  |   4 +-
 .../operation/transform/CopyTransform.java         |  10 +-
 .../transform/DefaultMathTransformFactory.java     |  10 +-
 .../transform/InterpolatedGeocentricTransform.java |   2 +-
 .../transform/InterpolatedMolodenskyTransform.java |   2 +-
 .../operation/transform/IterationStrategy.java     |   4 +-
 .../operation/transform/LinearTransform.java       |   2 +-
 .../operation/transform/MathTransforms.java        |   4 +-
 .../operation/transform/MolodenskyTransform.java   |   4 +-
 .../operation/transform/PassThroughTransform.java  |   2 +-
 .../operation/transform/ProjectiveTransform.java   |   4 +-
 .../operation/transform/ScaleTransform.java        |   6 +-
 .../operation/transform/TranslationTransform.java  |   4 +-
 .../apache/sis/geometry/AbstractEnvelopeTest.java  |  14 +-
 .../org/apache/sis/geometry/ArrayEnvelopeTest.java |  12 +-
 .../apache/sis/geometry/CoordinateFormatTest.java  |   4 +-
 .../apache/sis/geometry/DirectPosition1DTest.java  |   4 +-
 .../apache/sis/geometry/DirectPosition2DTest.java  |   6 +-
 .../org/apache/sis/geometry/EnvelopesTest.java     |   4 +-
 .../sis/geometry/GeneralDirectPositionTest.java    |   6 +-
 .../apache/sis/geometry/GeneralEnvelopeTest.java   |  14 +-
 .../org/apache/sis/geometry/SubEnvelopeTest.java   |  30 +--
 .../provider/GeographicOffsetsTest.java            |   2 +-
 .../apache/sis/referencing/cs/HardCodedAxes.java   |  44 ++--
 .../referencing/datum/TimeDependentBWPTest.java    |   2 +-
 .../operation/CoordinateOperationFinderTest.java   |   2 +-
 .../operation/HardCodedConversions.java            |   6 +-
 .../builder/LinearTransformBuilderTest.java        |   4 +-
 .../referencing/operation/matrix/MatricesTest.java |   2 +-
 .../operation/projection/AlbersEqualAreaTest.java  |  12 +-
 .../transform/AbstractMathTransformTest.java       |   2 +-
 .../operation/transform/CoordinateDomain.java      |  66 ++---
 .../operation/transform/CoordinateDomainTest.java  |   6 +-
 .../operation/transform/CopyTransformTest.java     |   2 +-
 .../operation/transform/PseudoTransform.java       |   2 +-
 .../org/apache/sis/test/ReferencingAssert.java     |  12 +-
 .../apache/sis/math/CompoundDirectPositions.java   |  26 +-
 .../src/main/java/org/apache/sis/math/Line.java    |  12 +-
 .../src/main/java/org/apache/sis/math/Plane.java   |   6 +-
 .../main/java/org/apache/sis/measure/Latitude.java |   4 +-
 .../java/org/apache/sis/measure/Longitude.java     |   4 +-
 .../java/org/apache/sis/util/resources/Errors.java |  10 +-
 .../apache/sis/util/resources/Errors.properties    |   2 +-
 .../apache/sis/util/resources/Errors_fr.properties |   2 +-
 .../java/org/apache/sis/test/TestUtilities.java    |   4 +-
 .../storage/earthobservation/LandsatReader.java    |   6 +-
 .../src/main/c/org_apache_sis_storage_gdal_PJ.c    |   4 +-
 .../sis/storage/geotiff/GridGeometryBuilder.java   |   6 +-
 .../apache/sis/storage/geotiff/Localization.java   |  12 +-
 .../apache/sis/internal/netcdf/impl/GridInfo.java  |   2 +-
 .../sis/internal/netcdf/ucar/GridWrapper.java      |   2 +-
 .../sis/internal/storage/MetadataBuilder.java      |  10 +-
 .../org/apache/sis/internal/storage/csv/Store.java |   2 +-
 110 files changed, 984 insertions(+), 966 deletions(-)

diff --git a/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java b/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java
index ad036bd..8c8cbe0 100644
--- a/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java
+++ b/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java
@@ -110,17 +110,17 @@ final class TransformCommand extends FormattedOutputCommand {
     private NumberFormat coordinateFormat;
 
     /**
-     * Width of ordinate values, in number of characters in ordinate {@link String} representations.
+     * Width of coordinate values, in number of characters in coordinate {@link String} representations.
      */
-    private int ordinateWidth;
+    private int coordinateWidth;
 
     /**
-     * Suggested number of fraction digits for each ordinate values.
+     * Suggested number of fraction digits for each coordinate values.
      */
     private int[] numFractionDigits;
 
     /**
-     * We will switch to scientific notation if the ordinate value to format is greater than this value.
+     * We will switch to scientific notation if the coordinate value to format is greater than this value.
      */
     private double[] thresholdForScientificNotation;
 
@@ -245,7 +245,7 @@ final class TransformCommand extends FormattedOutputCommand {
          * compute the number of digits to format and perform the actual coordinate operations.
          */
         if (!points.isEmpty()) {
-            ordinateWidth    = 15;                                      // Must be set before computeNumFractionDigits(…).
+            coordinateWidth  = 15;                                      // Must be set before computeNumFractionDigits(…).
             coordinateFormat = NumberFormat.getInstance(Locale.US);
             coordinateFormat.setGroupingUsed(false);
             computeNumFractionDigits(operation.getTargetCRS().getCoordinateSystem());
@@ -476,7 +476,7 @@ final class TransformCommand extends FormattedOutputCommand {
             if (!unit.isEmpty()) {
                 name = name + " (" + unit + ')';
             }
-            printQuotedText(name, ordinateWidth, X364.FOREGROUND_CYAN);
+            printQuotedText(name, coordinateWidth, X364.FOREGROUND_CYAN);
         }
     }
 
@@ -507,7 +507,7 @@ final class TransformCommand extends FormattedOutputCommand {
             if (precision > 0) {
                 numFractionDigits[i] = Math.max(DecimalFunctions.fractionDigitsForDelta(precision, false) + 1, 0);
             }
-            thresholdForScientificNotation[i] = MathFunctions.pow10(ordinateWidth - 1 - numFractionDigits[i]);
+            thresholdForScientificNotation[i] = MathFunctions.pow10(coordinateWidth - 1 - numFractionDigits[i]);
         }
     }
 
@@ -599,7 +599,7 @@ final class TransformCommand extends FormattedOutputCommand {
             }
             /*
              * At this point we got the coordinates and they have the expected number of dimensions.
-             * Now perform the coordinate operation and print each ordinate values.  We will switch
+             * Now perform the coordinate operation and print each coordinate values. We will switch
              * to scientific notation if the coordinate is much larger than expected.
              */
             mt.transform(coordinates, 0, result, 0, 1);
@@ -616,7 +616,7 @@ final class TransformCommand extends FormattedOutputCommand {
                     coordinateFormat.setMaximumFractionDigits(numFractionDigits[i]);
                     s = coordinateFormat.format(value);
                 }
-                out.print(CharSequences.spaces(ordinateWidth - s.length()));
+                out.print(CharSequences.spaces(coordinateWidth - s.length()));
                 out.print(s);
             }
             /*
diff --git a/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java b/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java
index e4e087c..f9a74bb 100644
--- a/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java
+++ b/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java
@@ -160,8 +160,8 @@ final class Transformer {
         for (int j=0; j<points.length; j++) {
             final double[] coords = points[j];
             if (coords != null) {                                               // Paranoiac check.
-                for (int i=sourcePt.ordinates.length; --i>=0;) {
-                    sourcePt.ordinates[i] = (i < coords.length) ? coords[i] : 0;
+                for (int i=sourcePt.coordinates.length; --i>=0;) {
+                    sourcePt.coordinates[i] = (i < coords.length) ? coords[i] : 0;
                 }
                 try {
                     result[j] = mt.transform(sourcePt, targetPt).getCoordinate();
diff --git a/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java b/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java
index 1e9dadd..efbb0ab 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java
@@ -35,10 +35,10 @@ final class GridCoordinatesView implements GridCoordinates {
     /**
      * A reference to the coordinate array of the enclosing grid envelope.
      */
-    private final long[] ordinates;
+    private final long[] coordinates;
 
     /**
-     * Index of the first value in the {@link #ordinates} array.
+     * Index of the first value in the {@link #coordinates} array.
      * This is 0 for low values, or {@link #getDimension()} for high values.
      */
     private final int offset;
@@ -46,8 +46,8 @@ final class GridCoordinatesView implements GridCoordinates {
     /**
      * Creates a new view over the low or high coordinates.
      */
-    GridCoordinatesView(final long[] ordinates, final int offset) {
-        this.ordinates = ordinates;
+    GridCoordinatesView(final long[] coordinates, final int offset) {
+        this.coordinates = coordinates;
         this.offset = offset;
     }
 
@@ -56,7 +56,7 @@ final class GridCoordinatesView implements GridCoordinates {
      */
     @Override
     public final int getDimension() {
-        return ordinates.length >>> 1;
+        return coordinates.length >>> 1;
     }
 
     /**
@@ -64,7 +64,7 @@ final class GridCoordinatesView implements GridCoordinates {
      */
     @Override
     public final long[] getCoordinateValues() {
-        return Arrays.copyOfRange(ordinates, offset, offset + getDimension());
+        return Arrays.copyOfRange(coordinates, offset, offset + getDimension());
     }
 
     /**
@@ -73,7 +73,7 @@ final class GridCoordinatesView implements GridCoordinates {
     @Override
     public final long getCoordinateValue(final int index) {
         ArgumentChecks.ensureValidIndex(getDimension(), index);
-        return ordinates[offset + index];
+        return coordinates[offset + index];
     }
 
     /**
@@ -100,7 +100,7 @@ final class GridCoordinatesView implements GridCoordinates {
         long code = -3;                             // Arbitrary seed for differentiating from Arrays.hashCode(long[]).
         final int end = offset + getDimension();
         for (int i=offset; i<end; i++) {
-            code = 31 * code + ordinates[i];
+            code = 31 * code + coordinates[i];
         }
         return Long.hashCode(code);
     }
@@ -126,7 +126,7 @@ final class GridCoordinatesView implements GridCoordinates {
             if (dimension == that.getDimension()) {
                 // TODO: use Arrays.equals(...) with JDK9 instead.
                 for (int i=0; i<dimension; i++) {
-                    if (ordinates[offset + i] != that.ordinates[that.offset + i]) {
+                    if (coordinates[offset + i] != that.coordinates[that.offset + i]) {
                         return false;
                     }
                 }
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java
index b7acd42..bbd8780 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java
@@ -123,17 +123,17 @@ final class ESRI extends Geometries<Geometry> {
     }
 
     /**
-     * Creates a polyline from the given ordinate values.
-     * Each {@link Double#NaN} ordinate value starts a new path.
+     * Creates a polyline from the given coordinate values.
+     * Each {@link Double#NaN} coordinate value starts a new path.
      */
     @Override
-    public Geometry createPolyline(final int dimension, final Vector... ordinates) {
+    public Geometry createPolyline(final int dimension, final Vector... coordinates) {
         if (dimension != 2) {
             throw unsupported(dimension);
         }
         boolean lineTo = false;
         final Polyline path = new Polyline();
-        for (final Vector v : ordinates) {
+        for (final Vector v : coordinates) {
             if (v != null) {
                 final int size = v.size();
                 for (int i=0; i<size;) {
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java
index c6950d7..a30b2a2 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java
@@ -259,27 +259,27 @@ public abstract class Geometries<G> {
      * Creates a two-dimensional point from the given coordinate. If the CRS is geographic, then the
      * (x,y) values should be (longitude, latitude) for compliance with usage in ESRI and JTS libraries.
      *
-     * @param  x  the first ordinate value.
-     * @param  y  the second ordinate value.
-     * @return the point for the given ordinate values.
+     * @param  x  the first coordinate value.
+     * @param  y  the second coordinate value.
+     * @return the point for the given coordinate values.
      *
      * @see #getCoordinate(Object)
      */
     public abstract Object createPoint(double x, double y);
 
     /**
-     * Creates a path or polyline from the given ordinate values.
-     * The array of ordinate vectors will be handled as if all vectors were concatenated in a single vector,
+     * Creates a path or polyline from the given coordinate values.
+     * The array of coordinate values will be handled as if all vectors were concatenated in a single vector,
      * ignoring {@code null} array elements.
-     * Each {@link Double#NaN} ordinate value in the concatenated vector starts a new path.
+     * Each {@link Double#NaN} coordinate value in the concatenated vector starts a new path.
      * The implementation returned by this method is an instance of {@link #rootClass}.
      *
-     * @param  dimension  the number of dimensions (2 or 3).
-     * @param  ordinates  sequence of (x,y) or (x,y,z) tuples.
+     * @param  dimension    the number of dimensions (2 or 3).
+     * @param  coordinates  sequence of (x,y) or (x,y,z) tuples.
      * @return the geometric object for the given points.
      * @throws UnsupportedOperationException if the geometry library can not create the requested path.
      */
-    public abstract G createPolyline(int dimension, Vector... ordinates);
+    public abstract G createPolyline(int dimension, Vector... coordinates);
 
     /**
      * Merges a sequence of polyline instances if the first instance is an implementation of this library.
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java
index 39c998f..20e2f6d 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java
@@ -141,7 +141,7 @@ final class JTS extends Geometries<Geometry> {
     /**
      * Creates a two-dimensional point from the given coordinate.
      *
-     * @return the point for the given ordinate values.
+     * @return the point for the given coordinate values.
      */
     @Override
     public Object createPoint(final double x, final double y) {
@@ -149,20 +149,20 @@ final class JTS extends Geometries<Geometry> {
     }
 
     /**
-     * Creates a polyline from the given ordinate values.
-     * Each {@link Double#NaN} ordinate value starts a new path.
+     * Creates a polyline from the given coordinate values.
+     * Each {@link Double#NaN} coordinate value starts a new path.
      *
      * @return the geometric object for the given points.
      */
     @Override
-    public Geometry createPolyline(final int dimension, final Vector... ordinates) {
+    public Geometry createPolyline(final int dimension, final Vector... coords) {
         final boolean is3D = (dimension == 3);
         if (!is3D && dimension != 2) {
             throw unsupported(dimension);
         }
         final List<Coordinate> coordinates = new ArrayList<>(32);
         final List<LineString> lines = new ArrayList<>();
-        for (final Vector v : ordinates) {
+        for (final Vector v : coords) {
             if (v != null) {
                 final int size = v.size();
                 for (int i=0; i<size;) {
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java
index 7691b60..f0a70f3 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java
@@ -111,13 +111,13 @@ final class Java2D extends Geometries<Shape> {
     }
 
     /**
-     * Creates a path from the given ordinate values.
-     * Each {@link Double#NaN} ordinate value starts a new path.
+     * Creates a path from the given coordinate values.
+     * Each {@link Double#NaN} coordinate value starts a new path.
      * The geometry may be backed by {@code float} or {@code double} primitive type,
      * depending on the type used by the given vectors.
      */
     @Override
-    public Shape createPolyline(final int dimension, final Vector... ordinates) {
+    public Shape createPolyline(final int dimension, final Vector... coordinates) {
         if (dimension != 2) {
             throw unsupported(dimension);
         }
@@ -127,7 +127,7 @@ final class Java2D extends Geometries<Shape> {
          */
         int length = 0;
         boolean isFloat = true;
-        for (final Vector v : ordinates) {
+        for (final Vector v : coordinates) {
             if (v != null) {
                 length = Math.addExact(length, v.size());
                 if (isFloat) {
@@ -139,8 +139,8 @@ final class Java2D extends Geometries<Shape> {
          * Note: Point2D is not an instance of Shape, so we can not make a special case for it.
          */
         length /= 2;
-        if (length == 2 && ordinates.length == 1) {
-            final Vector v = ordinates[0];
+        if (length == 2 && coordinates.length == 1) {
+            final Vector v = coordinates[0];
             final double x1, y1, x2, y2;
             if (!Double.isNaN(x1 = v.doubleValue(0)) &&
                 !Double.isNaN(y1 = v.doubleValue(1)) &&
@@ -155,7 +155,7 @@ final class Java2D extends Geometries<Shape> {
         final Path2D path = isFloat ? new Path2D.Float (Path2D.WIND_NON_ZERO, length)
                                     : new Path2D.Double(Path2D.WIND_NON_ZERO, length);
         boolean lineTo = false;
-        for (final Vector v : ordinates) {
+        for (final Vector v : coordinates) {
             final int size = v.size();
             for (int i=0; i<size;) {
                 final double x = v.doubleValue(i++);
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java
index ffd79c7..c60dbd9 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java
@@ -239,12 +239,12 @@ public final class MovingFeature {
                         p = p.previous;
                     }
                     warningListener.accept(Resources.forLocale(null).getLogRecord(Level.WARNING,
-                            Resources.Keys.UnexpectedNumberOfOrdinates_4, featureName, new Date(p.startTime), dimension, length));
+                            Resources.Keys.UnexpectedNumberOfCoordinates_4, featureName, new Date(p.startTime), dimension, length));
                 }
                 continue;
             }
             /*
-             * At this point we have a non-empty valid sequence of ordinate values. If the first point of current
+             * At this point we have a non-empty valid sequence of coordinate values. If the first point of current
              * vector is equals to the last point of previous vector, assume that they form a continuous polyline.
              */
             if (previous != null) {
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java
index 9f35c4e..2181205 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java
@@ -300,9 +300,9 @@ public final class Resources extends IndexedResourceBundle {
         public static final short UnexpectedNumberOfComponents_4 = 17;
 
         /**
-         * The “{0}” feature at {1} has a {3} ordinate values, while we expected a multiple of {2}.
+         * The “{0}” feature at {1} has a {3} coordinate values, while we expected a multiple of {2}.
          */
-        public static final short UnexpectedNumberOfOrdinates_4 = 22;
+        public static final short UnexpectedNumberOfCoordinates_4 = 22;
 
         /**
          * Raster data type ‘{0}’ is unknown or unsupported.
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties
index 6f6a38e..d0bcc90 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties
@@ -65,7 +65,7 @@ TooManyQualitatives               = Too many qualitative categories.
 UnavailableGeometryLibrary_1      = The {0} geometry library is not available in current runtime environment.
 UnexpectedNumberOfBands_2         = Expected {0} bands but got {1}.
 UnexpectedNumberOfComponents_4    = The \u201c{1}\u201d value given to \u201c{0}\u201d property should be separable in {2} components, but we got {3}.
-UnexpectedNumberOfOrdinates_4     = The \u201c{0}\u201d feature at {1} has a {3} ordinate values, while we expected a multiple of {2}.
+UnexpectedNumberOfCoordinates_4   = The \u201c{0}\u201d feature at {1} has a {3} coordinate values, while we expected a multiple of {2}.
 UnknownDataType_1                 = Raster data type \u2018{0}\u2019 is unknown or unsupported.
 UnresolvedFeatureName_1           = Feature named \u201c{0}\u201d has not yet been resolved.
 UnspecifiedCRS                    = Coordinate reference system is unspecified.
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties
index 773f28c..b6eccd1 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties
@@ -71,7 +71,7 @@ TooManyQualitatives               = Trop de cat\u00e9gories qualitatives.
 UnavailableGeometryLibrary_1      = La biblioth\u00e8que de g\u00e9om\u00e9tries {0} n\u2019est pas disponible dans l\u2019environnement d\u2019ex\u00e9cution actuel.
 UnexpectedNumberOfBands_2         = On attendait {0} bandes mais {1} ont \u00e9t\u00e9 sp\u00e9cifi\u00e9es.
 UnexpectedNumberOfComponents_4    = La valeur \u00ab\u202f{1}\u202f\u00bb donn\u00e9e \u00e0 la propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb devrait \u00eatre s\u00e9parable en {2} composantes, mais on en a obtenus {3}.
-UnexpectedNumberOfOrdinates_4     = L\u2019entit\u00e9 nomm\u00e9e \u00ab\u202f{0}\u202f\u00bb \u00e0 {1} contient {3} ordonn\u00e9es, alors qu\u2019on attendait un multiple de {2}.
+UnexpectedNumberOfCoordinates_4   = L\u2019entit\u00e9 nomm\u00e9e \u00ab\u202f{0}\u202f\u00bb \u00e0 {1} contient {3} coordonn\u00e9es, alors qu\u2019on attendait un multiple de {2}.
 UnknownDataType_1                 = Le type de donn\u00e9es raster \u2018{0}\u2019 est inconnu ou non-support\u00e9.
 UnresolvedFeatureName_1           = L\u2019entit\u00e9 nomm\u00e9e \u00ab\u202f{0}\u202f\u00bb n\u2019a pas encore \u00e9t\u00e9 r\u00e9solue.
 UnspecifiedCRS                    = Le syst\u00e8me de r\u00e9f\u00e9rence des coordonn\u00e9es n\u2019a pas \u00e9t\u00e9 sp\u00e9cifi\u00e9.
diff --git a/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java b/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java
index 58a197a..290c260 100644
--- a/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java
+++ b/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java
@@ -334,7 +334,7 @@ public final strictfp class GridDerivationTest extends TestCase {
 
         final GeneralDirectPosition geo3dUpperCorner = new GeneralDirectPosition(geo3d.getUpperCorner());
         IntStream.range(0, geo3dUpperCorner.getDimension())
-                .forEach(idx -> geo3dUpperCorner.ordinates[idx] -= 1e-7);
+                .forEach(idx -> geo3dUpperCorner.coordinates[idx] -= 1e-7);
 
         slice = base.derive()
                 .slice(geo3dUpperCorner)
diff --git a/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java b/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java
index fbf8d7c..a56a050 100644
--- a/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java
+++ b/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java
@@ -223,7 +223,7 @@ public class ReferencingServices extends OptionalDependency {
 
     /**
      * Sets a vertical extent with the value inferred from the given envelope.
-     * Only the vertical ordinates are extracted; all other ordinates are ignored.
+     * Only the vertical coordinates are extracted; all other coordinates are ignored.
      *
      * @param  envelope  the source envelope.
      * @param  target    the target vertical extent.
@@ -236,7 +236,7 @@ public class ReferencingServices extends OptionalDependency {
 
     /**
      * Sets a temporal extent with the value inferred from the given envelope.
-     * Only the temporal ordinates are extracted; all other ordinates are ignored.
+     * Only the temporal coordinates are extracted; all other coordinates are ignored.
      *
      * @param  envelope  the source envelope.
      * @param  target    the target temporal extent.
diff --git a/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java b/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java
index a8738ee..f913f50 100644
--- a/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java
+++ b/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java
@@ -428,7 +428,7 @@ public class DefaultGeographicBoundingBox extends AbstractGeographicExtent imple
             throws IllegalArgumentException
     {
         if (southBoundLatitude > northBoundLatitude) {                          // Accept NaN.
-            throw new IllegalArgumentException(Errors.format(Errors.Keys.IllegalOrdinateRange_3,
+            throw new IllegalArgumentException(Errors.format(Errors.Keys.IllegalCoordinateRange_3,
                     new Latitude(southBoundLatitude), new Latitude(northBoundLatitude),
                     Vocabulary.format(Vocabulary.Keys.Latitude)));
         }
@@ -552,7 +552,7 @@ public class DefaultGeographicBoundingBox extends AbstractGeographicExtent imple
     /*
      * IMPLEMENTATION NOTE: For the handling of anti-meridian spanning in union and intersection operations,
      * this class applies a different strategy than GeneralEnvelope. Instead than trying to work directly with
-     * the ordinate values without adding or removing offset (which may cause rounding errors), we apply a ±360°
+     * the coordinate values without adding or removing offset (which may cause rounding errors), we apply a ±360°
      * shift on longitude values. This simpler strategy is okay here because the range is fixed in the code (not
      * an arbitrarily high range), and GeographicBoundingBox are approximations by definition anyway.
      */
diff --git a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java
index 253501c..f675f6c 100644
--- a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java
+++ b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java
@@ -286,7 +286,7 @@ public class GeohashReferenceSystem extends ReferencingByIdentifiers {
             /*
              * The current implementation assumes a two-dimensional coordinates. The 'isEven' boolean takes
              * the 'true' value for longitude, and 'false' for latitude. We could extend this algorithm to
-             * the multi-dimensional case by replacing 'isEven' by a counter over the ordinate dimension.
+             * the multi-dimensional case by replacing 'isEven' by a counter over the coordinate dimension.
              */
             boolean isEven = true;
             double xmin = Longitude.MIN_VALUE, ymin = Latitude.MIN_VALUE;
@@ -381,7 +381,7 @@ public class GeohashReferenceSystem extends ReferencingByIdentifiers {
             /*
              * The current implementation assumes a two-dimensional coordinates. The 'isEven' boolean takes
              * the 'true' value for longitude, and 'false' for latitude. We could extend this algorithm to
-             * the multi-dimensional case by replacing 'isEven' by a counter over the ordinate dimension.
+             * the multi-dimensional case by replacing 'isEven' by a counter over the coordinate dimension.
              */
             boolean isEven = true;
             minX = Longitude.MIN_VALUE;
diff --git a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java
index 7667c0a..b176415 100644
--- a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java
+++ b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java
@@ -642,7 +642,7 @@ public class MilitaryGridReferenceSystem extends ReferencingByIdentifiers {
          * The Coordinate Reference System (CRS) associated to the returned position depends on the given reference.
          *
          * @param  reference  MGRS string to decode.
-         * @return a new position with the longitude at ordinate 0 and latitude at ordinate 1.
+         * @return a new position with the longitude at coordinate 0 and latitude at coordinate 1.
          * @throws TransformException if an error occurred while parsing the given string.
          */
         public Location decode(final CharSequence reference) throws TransformException {
@@ -1482,7 +1482,7 @@ public class MilitaryGridReferenceSystem extends ReferencingByIdentifiers {
             final int zone       = isUTM ? ZONER.zone(φ, λ) : POLE;
             final int signedZone = MathFunctions.isNegative(φ) ? -zone : zone;
             if (signedZone == 0) {
-                // Zero value at this point is the result of NaN of infinite ordinate value.
+                // Zero value at this point is the result of NaN of infinite coordinate value.
                 throw new GazetteerException(Errors.format(Errors.Keys.NotANumber_1, "longitude"));
             }
             /*
diff --git a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java
index 276f8f5..7a98cbd 100644
--- a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java
+++ b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java
@@ -157,7 +157,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
     }
 
     /**
-     * Returns the centroid ordinate value for the specified dimension.
+     * Returns the centroid coordinate value for the specified dimension.
      */
     @Override
     public final double getOrdinate(final int dimension) {
@@ -165,7 +165,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
     }
 
     /**
-     * Returns the minimal ordinate value for the specified dimension.
+     * Returns the minimal coordinate value for the specified dimension.
      */
     @Override
     public final double getMinimum(final int dimension) {
@@ -177,7 +177,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
     }
 
     /**
-     * Returns the maximal ordinate value for the specified dimension.
+     * Returns the maximal coordinate value for the specified dimension.
      */
     @Override
     public final double getMaximum(final int dimension) {
@@ -189,7 +189,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
     }
 
     /**
-     * Returns the median ordinate value for the specified dimension.
+     * Returns the median coordinate value for the specified dimension.
      */
     @Override
     public final double getMedian(final int dimension) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
index f512d0a..6d62407 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
@@ -98,23 +98,22 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
     }
 
     /**
-     * Returns a sequence of numbers that hold the coordinate of this position in its
-     * reference system.
+     * Returns a sequence of numbers that hold the coordinate of this position in its reference system.
      *
      * @return the coordinates.
      */
     @Override
     public double[] getCoordinate() {
-        final double[] ordinates = new double[getDimension()];
-        for (int i=0; i<ordinates.length; i++) {
-            ordinates[i] = getOrdinate(i);
+        final double[] coordinates = new double[getDimension()];
+        for (int i=0; i<coordinates.length; i++) {
+            coordinates[i] = getOrdinate(i);
         }
-        return ordinates;
+        return coordinates;
     }
 
     /**
      * Sets this direct position to the given position. If the given position is
-     * {@code null}, then all ordinate values are set to {@link Double#NaN NaN}.
+     * {@code null}, then all coordinate values are set to {@link Double#NaN NaN}.
      *
      * <p>If this position and the given position have a non-null CRS, then the default implementation
      * requires the CRS to be {@linkplain Utilities#equalsIgnoreMetadata equals (ignoring metadata)},
@@ -150,19 +149,19 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
 
     /**
      * Ensures that the position is contained in the coordinate system domain.
-     * For each dimension, this method compares the ordinate values against the
+     * For each dimension, this method compares the coordinate values against the
      * limits of the coordinate system axis for that dimension.
-     * If some ordinates are out of range, then there is a choice depending on the
+     * If some coordinates are out of range, then there is a choice depending on the
      * {@linkplain CoordinateSystemAxis#getRangeMeaning() axis range meaning}:
      *
      * <ul>
-     *   <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> ordinates), then values
+     *   <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> coordinates), then values
      *       greater than the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximal value}
      *       are replaced by the axis maximum, and values smaller than the
      *       {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimal value}
      *       are replaced by the axis minimum.</li>
      *
-     *   <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> ordinates), then
+     *   <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> coordinates), then
      *       a multiple of the axis range (e.g. 360° for longitudes) is added or subtracted.</li>
      * </ul>
      *
@@ -178,24 +177,24 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
             final int dimension = getDimension();
             final CoordinateSystem cs = crs.getCoordinateSystem();
             for (int i=0; i<dimension; i++) {
-                double ordinate = getOrdinate(i);
+                double coordinate = getOrdinate(i);
                 final CoordinateSystemAxis axis = cs.getAxis(i);
                 final double  minimum = axis.getMinimumValue();
                 final double  maximum = axis.getMaximumValue();
                 final RangeMeaning rm = axis.getRangeMeaning();
                 if (RangeMeaning.EXACT.equals(rm)) {
-                         if (ordinate < minimum) ordinate = minimum;
-                    else if (ordinate > maximum) ordinate = maximum;
+                         if (coordinate < minimum) coordinate = minimum;
+                    else if (coordinate > maximum) coordinate = maximum;
                     else continue;
                 } else if (RangeMeaning.WRAPAROUND.equals(rm)) {
                     final double csSpan = maximum - minimum;
-                    final double shift  = Math.floor((ordinate - minimum) / csSpan) * csSpan;
+                    final double shift  = Math.floor((coordinate - minimum) / csSpan) * csSpan;
                     if (shift == 0) {
                         continue;
                     }
-                    ordinate -= shift;
+                    coordinate -= shift;
                 }
-                setOrdinate(i, ordinate);
+                setOrdinate(i, coordinate);
                 changed = true;
             }
         }
@@ -205,7 +204,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
     /**
      * Formats this position in the <cite>Well Known Text</cite> (WKT) format.
      * The format is like below, where {@code x₀}, {@code x₁}, {@code x₂}, <i>etc.</i>
-     * are the ordinate values at index 0, 1, 2, <i>etc.</i>:
+     * are the coordinate values at index 0, 1, 2, <i>etc.</i>:
      *
      * {@preformat wkt
      *   POINT[x₀ x₁ x₂ …]
@@ -232,7 +231,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
     /**
      * Formats this position in the <cite>Well Known Text</cite> (WKT) format.
      * The returned string is like below, where {@code x₀}, {@code x₁}, {@code x₂}, <i>etc.</i>
-     * are the ordinate values at index 0, 1, 2, <i>etc.</i>:
+     * are the coordinate values at index 0, 1, 2, <i>etc.</i>:
      *
      * {@preformat wkt
      *   POINT(x₀ x₁ x₂ …)
@@ -255,7 +254,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
      * (WKT) format.
      *
      * @param  position           the position to format.
-     * @param  isSinglePrecision  {@code true} if every ordinate values can be casted to {@code float}.
+     * @param  isSinglePrecision  {@code true} if every coordinate values can be casted to {@code float}.
      * @return the point as a {@code POINT} in WKT format.
      *
      * @see ArraysExt#isSinglePrecision(double[])
@@ -269,11 +268,11 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
             char separator = '(';
             for (int i=0; i<dimension; i++) {
                 buffer.append(separator);
-                final double ordinate = position.getOrdinate(i);
+                final double coordinate = position.getOrdinate(i);
                 if (isSinglePrecision) {
-                    buffer.append((float) ordinate);
+                    buffer.append((float) coordinate);
                 } else {
-                    buffer.append(ordinate);
+                    buffer.append(coordinate);
                 }
                 trimFractionalPart(buffer);
                 separator = ' ';
@@ -287,7 +286,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
      * Parses the given WKT.
      *
      * @param  wkt  the WKT to parse.
-     * @return the ordinates, or {@code null} if none.
+     * @return the coordinates, or {@code null} if none.
      * @throws NumberFormatException if a number can not be parsed.
      * @throws IllegalArgumentException if the parenthesis are not balanced.
      */
@@ -342,10 +341,10 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
         }
         /*
          * Index i is either at the beginning of a number or at the closing parenthesis.
-         * Now process every space-separated ordinates until we reach the closing parenthesis
+         * Now process every space-separated coordinates until we reach the closing parenthesis
          * or the end of string.
          */
-        double[] ordinates = new double[2];
+        double[] coordinates = new double[2];
         int dimension = 0;
 parse:  while (i < length) {
             final int start = i;
@@ -362,10 +361,10 @@ parse:  while (i < length) {
              * IllegalArgumentException subclass, so we are compliant with the contract.
              */
             final double value = Double.parseDouble(wkt.subSequence(start, i).toString());
-            if (dimension == ordinates.length) {
-                ordinates = Arrays.copyOf(ordinates, dimension*2);
+            if (dimension == coordinates.length) {
+                coordinates = Arrays.copyOf(coordinates, dimension*2);
             }
-            ordinates[dimension++] = value;
+            coordinates[dimension++] = value;
             /*
              * Skip whitespaces. If we reach the end of string without finding
              * the closing parenthesis, check if we were suppose to have any.
@@ -378,7 +377,7 @@ parse:  while (i < length) {
                 c = Character.codePointAt(wkt, i);
             }
         }
-        return ArraysExt.resize(ordinates, dimension);
+        return ArraysExt.resize(coordinates, dimension);
     }
 
     /**
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java
index 77f14b1..6a55239 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java
@@ -264,7 +264,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * A coordinate position consisting of all the lower ordinate values.
+     * A coordinate position consisting of all the lower coordinate values.
      * The default implementation returns a view over the {@link #getLower(int)} method,
      * so changes in this envelope will be immediately reflected in the returned direct position.
      * If the particular case of the {@code GeneralEnvelope} subclass, the returned position
@@ -279,7 +279,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
      * lower corner longitude greater than the upper corner longitude. Such extended interpretation applies
      * mostly to axes having {@code WRAPAROUND} range meaning.</div>
      *
-     * @return a view over the lower corner, typically (but not necessarily) containing minimal ordinate values.
+     * @return a view over the lower corner, typically (but not necessarily) containing minimal coordinate values.
      */
     @Override
     public DirectPosition getLowerCorner() {
@@ -289,7 +289,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * A coordinate position consisting of all the upper ordinate values.
+     * A coordinate position consisting of all the upper coordinate values.
      * The default implementation returns a view over the {@link #getUpper(int)} method,
      * so changes in this envelope will be immediately reflected in the returned direct position.
      * If the particular case of the {@code GeneralEnvelope} subclass, the returned position
@@ -304,7 +304,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
      * upper corner longitude less than the lower corner longitude. Such extended interpretation applies
      * mostly to axes having {@code WRAPAROUND} range meaning.</div>
      *
-     * @return a view over the upper corner, typically (but not necessarily) containing maximal ordinate values.
+     * @return a view over the upper corner, typically (but not necessarily) containing maximal coordinate values.
      */
     @Override
     public DirectPosition getUpperCorner() {
@@ -314,7 +314,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * A coordinate position consisting of all the median ordinate values.
+     * A coordinate position consisting of all the median coordinate values.
      * The default implementation returns a view over the {@link #getMedian(int)} method,
      * so changes in this envelope will be immediately reflected in the returned direct position.
      *
@@ -327,38 +327,38 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * Returns the limit in the direction of decreasing ordinate values in the specified dimension.
+     * Returns the limit in the direction of decreasing coordinate values in the specified dimension.
      * This is usually the algebraic {@linkplain #getMinimum(int) minimum}, except if this envelope
      * spans the anti-meridian.
      *
-     * @param  dimension  the dimension for which to obtain the ordinate value.
-     * @return the starting ordinate value at the given dimension.
+     * @param  dimension  the dimension for which to obtain the coordinate value.
+     * @return the starting coordinate value at the given dimension.
      * @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
      *         than the {@linkplain #getDimension() envelope dimension}.
      */
     public abstract double getLower(int dimension) throws IndexOutOfBoundsException;
 
     /**
-     * Returns the limit in the direction of increasing ordinate values in the specified dimension.
+     * Returns the limit in the direction of increasing coordinate values in the specified dimension.
      * This is usually the algebraic {@linkplain #getMaximum(int) maximum}, except if this envelope
      * spans the anti-meridian.
      *
-     * @param  dimension  the dimension for which to obtain the ordinate value.
-     * @return the starting ordinate value at the given dimension.
+     * @param  dimension  the dimension for which to obtain the coordinate value.
+     * @return the starting coordinate value at the given dimension.
      * @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
      *         than the {@linkplain #getDimension() envelope dimension}.
      */
     public abstract double getUpper(int dimension) throws IndexOutOfBoundsException;
 
     /**
-     * Returns the minimal ordinate value for the specified dimension. In the typical case
+     * Returns the minimal coordinate value for the specified dimension. In the typical case
      * of non-empty envelopes <em>not</em> spanning the anti-meridian, this method returns the
      * {@link #getLower(int)} value verbatim. In the case of envelope spanning the anti-meridian,
      * this method returns the {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimum value}.
      * If the range in the given dimension is invalid, then this method returns {@code NaN}.
      *
-     * @param  dimension  the dimension for which to obtain the ordinate value.
-     * @return the minimal ordinate value at the given dimension.
+     * @param  dimension  the dimension for which to obtain the coordinate value.
+     * @return the minimal coordinate value at the given dimension.
      * @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
      *         than the {@linkplain #getDimension() envelope dimension}.
      */
@@ -373,14 +373,14 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * Returns the maximal ordinate value for the specified dimension. In the typical case
+     * Returns the maximal coordinate value for the specified dimension. In the typical case
      * of non-empty envelopes <em>not</em> spanning the anti-meridian, this method returns the
      * {@link #getUpper(int)} value verbatim. In the case of envelope spanning the anti-meridian,
      * this method returns the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximum value}.
      * If the range in the given dimension is invalid, then this method returns {@code NaN}.
      *
-     * @param  dimension  the dimension for which to obtain the ordinate value.
-     * @return the maximal ordinate value at the given dimension.
+     * @param  dimension  the dimension for which to obtain the coordinate value.
+     * @return the maximal coordinate value at the given dimension.
      * @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
      *         than the {@linkplain #getDimension() envelope dimension}.
      */
@@ -395,7 +395,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * Returns the median ordinate along the specified dimension.
+     * Returns the median coordinate along the specified dimension.
      * In most cases, the result is equals (minus rounding error) to:
      *
      * {@preformat java
@@ -412,8 +412,8 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
      * space. If the axis range meaning is not {@code WRAPAROUND}, then this method returns
      * {@link Double#NaN NaN}.
      *
-     * @param  dimension  the dimension for which to obtain the ordinate value.
-     * @return the median ordinate at the given dimension, or {@link Double#NaN}.
+     * @param  dimension  the dimension for which to obtain the coordinate value.
+     * @return the median coordinate at the given dimension, or {@link Double#NaN}.
      * @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
      *         than the {@linkplain #getDimension() envelope dimension}.
      */
@@ -588,7 +588,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
             envelopes[0] = this;
         } else {
             /*
-             * Need to create at least 2 envelopes. Instantiate now all envelopes with ordinate values
+             * Need to create at least 2 envelopes. Instantiate now all envelopes with coordinate values
              * initialized to a copy of this envelope. We will write directly in their internal arrays later.
              */
             double[] c = new double[dimension * 2];
@@ -596,26 +596,26 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
                 c[i            ] = getLower(i);
                 c[i + dimension] = getUpper(i);
             }
-            final double[][] ordinates = new double[envelopes.length][];
+            final double[][] coordinates = new double[envelopes.length][];
             for (int i=0; i<envelopes.length; i++) {
                 final GeneralEnvelope envelope = new GeneralEnvelope(i == 0 ? c : c.clone());
                 envelope.crs = crs;
                 envelopes[i] = envelope;
-                ordinates[i] = envelope.ordinates;
+                coordinates[i] = envelope.coordinates;
             }
             /*
-             * Assign the minimum and maximum ordinate values in the dimension where a wraparound has been found.
+             * Assign the minimum and maximum coordinate values in the dimension where a wraparound has been found.
              * The 'for' loop below iterates only over the 'i' values for which the 'isWrapAround' bit is set to 1.
              */
-            int mask = 1;               // For identifying whether we need to set the lower or the upper ordinate.
+            int mask = 1;               // For identifying whether we need to set the lower or the upper coordinate.
             @SuppressWarnings("null")
             final CoordinateSystem cs = crs.getCoordinateSystem();            // Should not be null at this point.
             for (int i; (i = Long.numberOfTrailingZeros(isWrapAround)) != Long.SIZE; isWrapAround &= ~(1L << i)) {
                 final CoordinateSystemAxis axis = cs.getAxis(i);
                 final double min = axis.getMinimumValue();
                 final double max = axis.getMaximumValue();
-                for (int j=0; j<ordinates.length; j++) {
-                    c = ordinates[j];
+                for (int j=0; j<coordinates.length; j++) {
+                    c = coordinates[j];
                     if ((j & mask) == 0) {
                         c[i + dimension] = max;
                     } else {
@@ -662,7 +662,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * Returns {@code false} if at least one ordinate value is not {@linkplain Double#NaN NaN}.
+     * Returns {@code false} if at least one coordinate value is not {@linkplain Double#NaN NaN}.
      * This {@code isAllNaN()} check is different than the {@link #isEmpty()} check since it
      * returns {@code false} for a partially initialized envelope, while {@code isEmpty()}
      * returns {@code false} only after all dimensions have been initialized.
@@ -696,7 +696,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     /**
      * Tests if a specified coordinate is inside the boundary of this envelope.
      * Both lower and upper values of this envelope are considered inclusive.
-     * If it least one ordinate value in the given point is {@link Double#NaN NaN},
+     * If it least one coordinate value in the given point is {@link Double#NaN NaN},
      * then this method returns {@code false}.
      *
      * <div class="section">Pre-conditions</div>
@@ -735,7 +735,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
                      * "Spanning the anti-meridian" case: if we reach this point, then the
                      * [upper...lower] range  (note the 'lower' and 'upper' interchanging)
                      * is actually a space outside the envelope and we have checked that
-                     * the ordinate value is outside that space.
+                     * the coordinate value is outside that space.
                      */
                     continue;
                 }
@@ -980,7 +980,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * Returns {@code true} if at least one ordinate in the given envelope
+     * Returns {@code true} if at least one coordinate in the given envelope
      * is {@link Double#NaN}. This is used for assertions only.
      */
     static boolean hasNaN(final Envelope envelope) {
@@ -988,7 +988,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
     }
 
     /**
-     * Returns {@code true} if at least one ordinate in the given position
+     * Returns {@code true} if at least one coordinate in the given position
      * is {@link Double#NaN}. This is used for assertions only.
      */
     static boolean hasNaN(final DirectPosition position) {
@@ -1025,7 +1025,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
      * To be considered equal, the two envelopes must have the same {@linkplain #getDimension() dimension}
      * and their CRS must be {@linkplain org.apache.sis.util.Utilities#equalsIgnoreMetadata equals,
      * ignoring metadata}. If at least one envelope has a null CRS, then the CRS are ignored and the
-     * ordinate values are compared as if the CRS were equal.
+     * coordinate values are compared as if the CRS were equal.
      *
      * @param  other          the envelope to compare with.
      * @param  eps            the tolerance value to use for numerical comparisons.
@@ -1175,11 +1175,11 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
             do {                                                        // Executed exactly twice.
                 for (int i=0; i<dimension; i++) {
                     buffer.append(i == 0 && !isUpper ? '(' : ' ');
-                    final double ordinate = (isUpper ? upperCorner : lowerCorner).getOrdinate(i);
+                    final double coordinate = (isUpper ? upperCorner : lowerCorner).getOrdinate(i);
                     if (isSinglePrecision) {
-                        buffer.append((float) ordinate);
+                        buffer.append((float) coordinate);
                     } else {
-                        buffer.append(ordinate);
+                        buffer.append(coordinate);
                     }
                     trimFractionalPart(buffer);
                 }
@@ -1261,7 +1261,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
             return getLower(dimension);
         }
 
-        /** Sets the ordinate value along the specified dimension. */
+        /** Sets the coordinate value along the specified dimension. */
         @Override public void setOrdinate(final int dimension, final double value) {
             setRange(dimension, value, getUpper(dimension));
         }
@@ -1277,7 +1277,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
             return getUpper(dimension);
         }
 
-        /** Sets the ordinate value along the specified dimension. */
+        /** Sets the coordinate value along the specified dimension. */
         @Override public void setOrdinate(final int dimension, final double value) {
             setRange(dimension, getLower(dimension), value);
         }
@@ -1309,8 +1309,8 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
      * preserving the immutable aspect of {@link ImmutableEnvelope} subclass among others.</p>
      *
      * @param  dimension  the dimension to set.
-     * @param  lower      the limit in the direction of decreasing ordinate values.
-     * @param  upper      the limit in the direction of increasing ordinate values.
+     * @param  lower      the limit in the direction of decreasing coordinate values.
+     * @param  upper      the limit in the direction of increasing coordinate values.
      * @throws UnmodifiableGeometryException if this envelope is not modifiable.
      * @throws IndexOutOfBoundsException if the given index is out of bounds.
      * @throws IllegalArgumentException if {@code lower > upper}, this envelope has a CRS
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java
index 14bbab6..9e87038 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java
@@ -44,11 +44,11 @@ import static org.apache.sis.internal.referencing.Formulas.isPoleToPole;
 
 
 /**
- * Base class of envelopes backed by an array. The ordinate values are stored in the {@link #ordinates} array.
- * The ordinate values of the lower corner are stored in the array portion from index {@link #beginIndex()}
- * inclusive to index {@link #endIndex()} exclusive. The ordinate values of the upper corner are stored in
+ * Base class of envelopes backed by an array. The coordinate values are stored in the {@link #coordinates} array.
+ * The coordinate values of the lower corner are stored in the array portion from index {@link #beginIndex()}
+ * inclusive to index {@link #endIndex()} exclusive. The coordinate values of the upper corner are stored in
  * the array portion from index {@code beginIndex() + d} inclusive to index {@code endIndex() + d} exclusive
- * where {@code d = ordinates.length >>> 1}.
+ * where {@code d = coordinates.length >>> 1}.
  *
  * <p>Unless otherwise indicated by a "{@code // Must be overridden in SubEnvelope}" comment, every methods
  * in {@code ArrayEnvelope} and subclasses must take in account the {@code beginIndex} and {@code endIndex}
@@ -64,14 +64,14 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
     /**
      * Serial number for inter-operability with different versions.
      */
-    private static final long serialVersionUID = 1657970968782634545L;
+    private static final long serialVersionUID = 3685400961133848112L;
 
     /**
-     * Ordinate values of lower and upper corners. Except for {@link SubEnvelope}, the length of
-     * this array is twice the number of dimensions. The first half contains the lower corner,
+     * Coordinate values of lower and upper corners. Except for {@link SubEnvelope}, the length
+     * of this array is twice the number of dimensions. The first half contains the lower corner,
      * while the second half contains the upper corner.
      */
-    final double[] ordinates;
+    final double[] coordinates;
 
     /**
      * The coordinate reference system, or {@code null}.
@@ -79,14 +79,14 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
     CoordinateReferenceSystem crs;
 
     /**
-     * Creates a new envelope using the given array of ordinate values. This constructor stores
+     * Creates a new envelope using the given array of coordinate values. This constructor stores
      * the given reference directly; it does <strong>not</strong> clone the given array. This is
      * the desired behavior for proper working of {@link SubEnvelope}.
      *
-     * @param  ordinates  the array of ordinate values to store directly (not cloned).
+     * @param  coordinates  the array of coordinate values to store directly (not cloned).
      */
-    ArrayEnvelope(final double[] ordinates) {
-        this.ordinates = ordinates;
+    ArrayEnvelope(final double[] coordinates) {
+        this.coordinates = coordinates;
     }
 
     /*
@@ -99,8 +99,8 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
      * If at least one corner is associated to a CRS, then the new envelope will also
      * be associated to that CRS.
      *
-     * @param  lowerCorner  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param  upperCorner  the limits in the direction of increasing ordinate values for each dimension.
+     * @param  lowerCorner  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param  upperCorner  the limits in the direction of increasing coordinate values for each dimension.
      * @throws MismatchedDimensionException if the two positions do not have the same dimension.
      * @throws MismatchedReferenceSystemException if the CRS of the two position are not equal.
      */
@@ -111,49 +111,49 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
         final int dimension = lowerCorner.getDimension();
         ensureDimensionMatches("crs", dimension, crs);
         ensureSameDimension(dimension, upperCorner.getDimension());
-        ordinates = new double[dimension * 2];
+        coordinates = new double[dimension * 2];
         for (int i=0; i<dimension; i++) {
-            ordinates[i            ] = lowerCorner.getOrdinate(i);
-            ordinates[i + dimension] = upperCorner.getOrdinate(i);
+            coordinates[i            ] = lowerCorner.getOrdinate(i);
+            coordinates[i + dimension] = upperCorner.getOrdinate(i);
         }
-        verifyRanges(crs, ordinates);
+        verifyRanges(crs, coordinates);
     }
 
     /**
-     * Constructs an envelope defined by two corners given as sequences of ordinate values.
+     * Constructs an envelope defined by two corners given as sequences of coordinate values.
      * The Coordinate Reference System is initially {@code null}.
      *
-     * @param  lowerCorner  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param  upperCorner  the limits in the direction of increasing ordinate values for each dimension.
+     * @param  lowerCorner  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param  upperCorner  the limits in the direction of increasing coordinate values for each dimension.
      * @throws MismatchedDimensionException if the two sequences do not have the same length.
      */
     public ArrayEnvelope(final double[] lowerCorner, final double[] upperCorner) throws MismatchedDimensionException {
         ensureNonNull("lowerCorner", lowerCorner);
         ensureNonNull("upperCorner", upperCorner);
         ensureSameDimension(lowerCorner.length, upperCorner.length);
-        ordinates = Arrays.copyOf(lowerCorner, lowerCorner.length + upperCorner.length);
-        System.arraycopy(upperCorner, 0, ordinates, lowerCorner.length, upperCorner.length);
+        coordinates = Arrays.copyOf(lowerCorner, lowerCorner.length + upperCorner.length);
+        System.arraycopy(upperCorner, 0, coordinates, lowerCorner.length, upperCorner.length);
     }
 
     /**
-     * Constructs an empty envelope of the specified dimension. All ordinates
+     * Constructs an empty envelope of the specified dimension. All coordinates
      * are initialized to 0 and the coordinate reference system is undefined.
      *
      * @param  dimension  the envelope dimension.
      */
     public ArrayEnvelope(final int dimension) {
-        ordinates = new double[dimension * 2];
+        coordinates = new double[dimension * 2];
     }
 
     /**
      * Constructs an empty envelope with the specified coordinate reference system.
-     * All ordinate values are initialized to 0.
+     * All coordinate values are initialized to 0.
      *
      * @param  crs  the coordinate reference system.
      */
     public ArrayEnvelope(final CoordinateReferenceSystem crs) {
         ensureNonNull("crs", crs);
-        ordinates = new double[crs.getCoordinateSystem().getDimension() * 2];
+        coordinates = new double[crs.getCoordinateSystem().getDimension() * 2];
         this.crs = crs;
     }
 
@@ -166,14 +166,14 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
         ensureNonNull("envelope", envelope);
         crs = envelope.getCoordinateReferenceSystem();
         final int dimension = envelope.getDimension();
-        ordinates = new double[dimension * 2];
+        coordinates = new double[dimension * 2];
         final DirectPosition lowerCorner = envelope.getLowerCorner();
         final DirectPosition upperCorner = envelope.getUpperCorner();
         for (int i=0; i<dimension; i++) {
-            ordinates[i]           = lowerCorner.getOrdinate(i);
-            ordinates[i+dimension] = upperCorner.getOrdinate(i);
+            coordinates[i]           = lowerCorner.getOrdinate(i);
+            coordinates[i+dimension] = upperCorner.getOrdinate(i);
         }
-        verifyRanges(crs, ordinates);
+        verifyRanges(crs, coordinates);
     }
 
     /**
@@ -186,20 +186,20 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
      */
     public ArrayEnvelope(final GeographicBoundingBox box) {
         ensureNonNull("box", box);
-        ordinates = new double[] {
+        coordinates = new double[] {
             box.getWestBoundLongitude(),
             box.getSouthBoundLatitude(),
             box.getEastBoundLongitude(),
             box.getNorthBoundLatitude()
         };
         if (Boolean.FALSE.equals(box.getInclusion())) {
-            ArraysExt.swap(ordinates, 0, ordinates.length >>> 1);
-            if (!isPoleToPole(ordinates[1], ordinates[3])) {
-                ArraysExt.swap(ordinates, 1, (ordinates.length >>> 1) + 1);
+            ArraysExt.swap(coordinates, 0, coordinates.length >>> 1);
+            if (!isPoleToPole(coordinates[1], coordinates[3])) {
+                ArraysExt.swap(coordinates, 1, (coordinates.length >>> 1) + 1);
             }
         }
         crs = CommonCRS.defaultGeographic();
-        verifyRanges(crs, ordinates);
+        verifyRanges(crs, coordinates);
     }
 
     /**
@@ -297,8 +297,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
         }
         if (levelParenth != 0) fail(wkt, ')');
         if (levelBracket != 0) fail(wkt, ']');
-        ordinates = ArraysExt.resize(minimum, maxDimension << 1);
-        System.arraycopy(maximum, 0, ordinates, maxDimension, maxDimension);
+        coordinates = ArraysExt.resize(minimum, maxDimension << 1);
+        System.arraycopy(maximum, 0, coordinates, maxDimension, maxDimension);
     }
 
     /**
@@ -320,7 +320,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     }
 
     /**
-     * Verifies the validity of the range of ordinates values in the given array.
+     * Verifies the validity of the range of coordinates values in the given array.
      * If the given CRS is null, then this method conservatively does nothing.
      * Otherwise this method performs the following verifications:
      *
@@ -328,7 +328,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      *   <li>{@code lower > upper} is allowed only for axes having {@link RangeMeaning#WRAPAROUND}.</li>
      * </ul>
      *
-     * This method does <strong>not</strong> verify if the ordinate values are between the axis minimum and
+     * This method does <strong>not</strong> verify if the coordinate values are between the axis minimum and
      * maximum values. This is because out-of-range values exist in practice but do not impact the working
      * of {@code add(…)}, {@code intersect(…)}, {@code contains(…)} and similar methods. This in contrast
      * with the checks listed above, where failure to met those conditions will cause the methods to
@@ -342,15 +342,15 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      *   <li>{@link SubEnvelope#setRange(int, double, double)}</li>
      * </ul>
      *
-     * @param  crs        the coordinate reference system, or {@code null}.
-     * @param  ordinates  the array of ordinate values to verify.
+     * @param  crs          the coordinate reference system, or {@code null}.
+     * @param  coordinates  the array of coordinate values to verify.
      */
-    static void verifyRanges(final CoordinateReferenceSystem crs, final double[] ordinates) {
+    static void verifyRanges(final CoordinateReferenceSystem crs, final double[] coordinates) {
         if (crs != null) {
-            final int dimension = ordinates.length >>> 1;
+            final int dimension = coordinates.length >>> 1;
             for (int i=0; i<dimension; i++) {
-                final double lower = ordinates[i];
-                final double upper = ordinates[i + dimension];
+                final double lower = coordinates[i];
+                final double upper = coordinates[i + dimension];
                 if (lower > upper && !isWrapAround(crs, i)) {
                     throw new IllegalArgumentException(illegalRange(crs, i, lower, upper));
                 }
@@ -359,7 +359,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     }
 
     /**
-     * Creates an error message for an illegal ordinates range at the given dimension.
+     * Creates an error message for an illegal coordinates range at the given dimension.
      * This is used for formatting the exception message.
      */
     static String illegalRange(final CoordinateReferenceSystem crs,
@@ -369,11 +369,11 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
         if (name == null) {
             name = dimension;       // Paranoiac fallback (name should never be null).
         }
-        return Errors.format(Errors.Keys.IllegalOrdinateRange_3, lower, upper, name);
+        return Errors.format(Errors.Keys.IllegalCoordinateRange_3, lower, upper, name);
     }
 
     /**
-     * Returns the index of the first valid ordinate value of the lower corner in the {@link #ordinates} array.
+     * Returns the index of the first valid coordinate value of the lower corner in the {@link #coordinates} array.
      * This is always 0, unless this envelope is a {@link SubEnvelope}.
      *
      * <p>See {@link #endIndex()} for the list of methods that need to be also overridden
@@ -384,8 +384,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     }
 
     /**
-     * Returns the index after the last valid ordinate value of the lower corner in the {@link #ordinates} array.
-     * This is always {@code ordinates.length >>> 1}, unless this envelope is a {@link SubEnvelope}.
+     * Returns the index after the last valid coordinate value of the lower corner in the {@link #coordinates} array.
+     * This is always {@code coordinates.length >>> 1}, unless this envelope is a {@link SubEnvelope}.
      *
      * <p>Unless otherwise indicated by a "{@code // Must be overridden in SubEnvelope}" comment, every methods
      * in {@code ArrayEnvelope} and subclasses must take in account the {@code beginIndex} and {@code endIndex}
@@ -402,7 +402,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      * </ul>
      */
     int endIndex() {
-        return ordinates.length >>> 1;
+        return coordinates.length >>> 1;
     }
 
     /**
@@ -414,7 +414,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      */
     @Override                                       // Must also be overridden in SubEnvelope
     public int getDimension() {
-        return ordinates.length >>> 1;
+        return coordinates.length >>> 1;
     }
 
     /**
@@ -435,8 +435,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      */
     @Override                                       // Must also be overridden in SubEnvelope
     public double getLower(final int dimension) throws IndexOutOfBoundsException {
-        ensureValidIndex(ordinates.length >>> 1, dimension);
-        return ordinates[dimension];
+        ensureValidIndex(coordinates.length >>> 1, dimension);
+        return coordinates[dimension];
     }
 
     /**
@@ -444,9 +444,9 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      */
     @Override                                       // Must also be overridden in SubEnvelope
     public double getUpper(final int dimension) throws IndexOutOfBoundsException {
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         ensureValidIndex(d, dimension);
-        return ordinates[dimension + d];
+        return coordinates[dimension + d];
     }
 
     /**
@@ -456,8 +456,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     public double getMinimum(final int dimension) throws IndexOutOfBoundsException {
         ensureValidIndex(endIndex(), dimension);
         final int i = dimension + beginIndex();
-        double lower = ordinates[i];
-        if (isNegative(ordinates[i + (ordinates.length >>> 1)] - lower)) {      // Special handling for -0.0
+        double lower = coordinates[i];
+        if (isNegative(coordinates[i + (coordinates.length >>> 1)] - lower)) {    // Special handling for -0.0
             final CoordinateSystemAxis axis = getAxis(crs, dimension);
             lower = isWrapAround(axis) ? axis.getMinimumValue() : Double.NaN;
         }
@@ -471,8 +471,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     public double getMaximum(final int dimension) throws IndexOutOfBoundsException {
         ensureValidIndex(endIndex(), dimension);
         final int i = dimension + beginIndex();
-        double upper = ordinates[i + (ordinates.length >>> 1)];
-        if (isNegative(upper - ordinates[i])) {                                 // Special handling for -0.0
+        double upper = coordinates[i + (coordinates.length >>> 1)];
+        if (isNegative(upper - coordinates[i])) {                               // Special handling for -0.0
             final CoordinateSystemAxis axis = getAxis(crs, dimension);
             upper = isWrapAround(axis) ? axis.getMaximumValue() : Double.NaN;
         }
@@ -486,8 +486,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     public double getMedian(final int dimension) throws IndexOutOfBoundsException {
         ensureValidIndex(endIndex(), dimension);
         final int i = dimension + beginIndex();
-        final double minimum = ordinates[i];
-        final double maximum = ordinates[i + (ordinates.length >>> 1)];
+        final double minimum = coordinates[i];
+        final double maximum = coordinates[i + (coordinates.length >>> 1)];
         double median = 0.5 * (minimum + maximum);
         if (isNegative(maximum - minimum)) {                                    // Special handling for -0.0
             median = fixMedian(getAxis(crs, dimension), median);
@@ -502,7 +502,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     public double getSpan(final int dimension) throws IndexOutOfBoundsException {
         ensureValidIndex(endIndex(), dimension);
         final int i = dimension + beginIndex();
-        double span = ordinates[i + (ordinates.length >>> 1)] - ordinates[i];
+        double span = coordinates[i + (coordinates.length >>> 1)] - coordinates[i];
         if (isNegative(span)) {                                                 // Special handling for -0.0
             span = fixSpan(getAxis(crs, dimension), span);
         }
@@ -519,9 +519,9 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
         if (beginIndex == endIndex) {
             return true;
         }
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int i=beginIndex; i<endIndex; i++) {
-            final double span = ordinates[i+d] - ordinates[i];
+            final double span = coordinates[i+d] - coordinates[i];
             if (!(span > 0)) {                                                  // Use '!' in order to catch NaN
                 if (!(isNegative(span) && isWrapAround(crs, i - beginIndex))) {
                     return true;
@@ -537,8 +537,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      */
     @Override                                       // Must also be overridden in SubEnvelope
     public boolean isAllNaN() {
-        for (int i=0; i<ordinates.length; i++) {
-            if (!Double.isNaN(ordinates[i])) {
+        for (int i=0; i<coordinates.length; i++) {
+            if (!Double.isNaN(coordinates[i])) {
                 return false;
             }
         }
@@ -551,7 +551,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      */
     @Override                                       // Must also be overridden in SubEnvelope
     public int hashCode() {
-        int code = Arrays.hashCode(ordinates);
+        int code = Arrays.hashCode(coordinates);
         if (crs != null) {
             code += crs.hashCode();
         }
@@ -561,7 +561,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
 
     /**
      * Computes the hash code value using the public API instead than direct access to the
-     * {@link #ordinates} array. This method is invoked from {@link SubEnvelope}.
+     * {@link #coordinates} array. This method is invoked from {@link SubEnvelope}.
      */
     final int hashCodeByAPI() {
         return super.hashCode();
@@ -574,7 +574,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
     public boolean equals(final Object object) {
         if (object != null && object.getClass() == getClass()) {
             final ArrayEnvelope that = (ArrayEnvelope) object;
-            return Arrays.equals(this.ordinates, that.ordinates) &&
+            return Arrays.equals(this.coordinates, that.coordinates) &&
                   Objects.equals(this.crs, that.crs);
         }
         return false;
@@ -582,7 +582,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
 
     /**
      * Compares the given object for equality using the public API instead than direct access
-     * to the {@link #ordinates} array. This method is invoked from {@link SubEnvelope}.
+     * to the {@link #coordinates} array. This method is invoked from {@link SubEnvelope}.
      */
     final boolean equalsByAPI(final Object object) {
         return super.equals(object);
@@ -593,6 +593,6 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
      */
     @Override
     public String toString() {
-        return toString(this, ArraysExt.isSinglePrecision(ordinates));
+        return toString(this, ArraysExt.isSinglePrecision(coordinates));
     }
 }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java
index 7e851f9..3ea8468 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java
@@ -62,13 +62,13 @@ import org.apache.sis.io.CompoundFormat;
 
 /**
  * Formats spatiotemporal coordinates using number, angle and date formats inferred from the coordinate system.
- * The format for each ordinate is inferred from the
+ * The format for each coordinate is inferred from the
  * {@linkplain org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis#getUnit() coordinate system units}
  * using the following rules:
  *
  * <ul>
- *   <li>Ordinate values in angular units are formatted as angles using {@link AngleFormat}.</li>
- *   <li>Ordinate values in temporal units are formatted as dates using {@link DateFormat}.</li>
+ *   <li>Coordinate values in angular units are formatted as angles using {@link AngleFormat}.</li>
+ *   <li>Coordinate values in temporal units are formatted as dates using {@link DateFormat}.</li>
  *   <li>Other values are formatted as numbers using {@link NumberFormat} followed by the unit symbol
  *       formatted by {@link org.apache.sis.measure.UnitFormat}.</li>
  * </ul>
@@ -163,13 +163,13 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
     private transient UnitConverter[] toFormatUnit;
 
     /**
-     * Units symbols. Used only for ordinate to be formatted as ordinary numbers.
-     * Non-null only if at least one ordinate is to be formatted that way.
+     * Units symbols. Used only for coordinate to be formatted as ordinary numbers.
+     * Non-null only if at least one coordinate is to be formatted that way.
      */
     private transient String[] unitSymbols;
 
     /**
-     * Flags the ordinate values that need to be inverted before to be formatted.
+     * Flags the coordinate values that need to be inverted before to be formatted.
      * This is needed for example if the axis is oriented toward past instead than future,
      * or toward west instead than east.
      *
@@ -178,7 +178,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
     private transient long negate;
 
     /**
-     * The time epochs. Non-null only if the at least on ordinate is to be formatted as a date.
+     * The time epochs. Non-null only if the at least on coordinate is to be formatted as a date.
      */
     private transient long[] epochs;
 
@@ -365,7 +365,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
     }
 
     /**
-     * Remembers that ordinate values at the given dimension will need to have their sign reverted.
+     * Remembers that coordinate values at the given dimension will need to have their sign reverted.
      */
     private void negate(final int dimension) {
         if (dimension >= Long.SIZE) {
@@ -575,7 +575,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
      *   <tr><td>{@link Date}</td>   <td>{@link DateFormat}</td>   <td>{@link SimpleDateFormat}</td></tr>
      * </table>
      *
-     * @param  valueType  the base type of ordinate values to parse and format:
+     * @param  valueType  the base type of coordinate values to parse and format:
      *                    {@code Number.class}, {@code Angle.class} or {@code Date.class}.
      * @return the pattern for fields of the given type, or {@code null} if not applicable.
      *
@@ -600,17 +600,17 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
      *
      * <ul>
      *   <li>If {@code valueType} is {@code Number.class}, then the pattern syntax shall be as described in the
-     *     {@link DecimalFormat} class. This pattern may be used for any ordinate to be formatted as plain number,
+     *     {@link DecimalFormat} class. This pattern may be used for any coordinate to be formatted as plain number,
      *     for example in {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian coordinate system}.</li>
      *   <li>If {@code valueType} is {@code Angle.class}, then the pattern syntax shall be as described in the
-     *     {@link AngleFormat} class. This pattern may be used for any ordinate to be formatted as latitude or longitude,
+     *     {@link AngleFormat} class. This pattern may be used for any coordinate to be formatted as latitude or longitude,
      *     for example in {@linkplain org.apache.sis.referencing.cs.DefaultEllipsoidalCS ellipsoidal coordinate system}.</li>
      *   <li>If {@code valueType} is {@code Date.class}, then the pattern syntax shall be as described in the
-     *     {@link SimpleDateFormat} class. This pattern may be used for any ordinate to be formatted as date and time,
+     *     {@link SimpleDateFormat} class. This pattern may be used for any coordinate to be formatted as date and time,
      *     for example in {@linkplain org.apache.sis.referencing.cs.DefaultTimeCS time coordinate system}.</li>
      * </ul>
      *
-     * @param  valueType  the base type of ordinate values to parse and format:
+     * @param  valueType  the base type of coordinate values to parse and format:
      *                    {@code Number.class}, {@code Angle.class} or {@code Date.class}.
      * @param  pattern    the pattern as specified in {@link DecimalFormat}, {@link AngleFormat}
      *                    or {@link SimpleDateFormat} javadoc.
@@ -703,11 +703,11 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
             dummy = new FieldPosition(0);
         }
         /*
-         * The format to use for each ordinate has been computed by 'initialize'.  The format array length
+         * The format to use for each coordinate has been computed by 'initialize'.  The format array length
          * should match the number of dimensions in the given position if the DirectPosition is consistent
          * with its CRS, but we will nevertheless verify has a paranoiac check.  If there is no CRS, or if
          * the DirectPosition dimension is (illegally) greater than the CRS dimension, then we will format
-         * the ordinate as a number.
+         * the coordinate as a number.
          */
         final int dimension = position.getDimension();
         for (int i=0; i < dimension; i++) {
@@ -759,7 +759,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
      * Parses a coordinate from the given character sequence.
      * This method presumes that the coordinate reference system is the {@linkplain #getDefaultCRS() default CRS}.
      * The parsing begins at the {@linkplain ParsePosition#getIndex() index} given by the {@code pos} argument.
-     * If parsing succeeds, then the {@code pos} index is updated to the index after the last ordinate value and
+     * If parsing succeeds, then the {@code pos} index is updated to the index after the last coordinate value and
      * the parsed coordinate is returned. Otherwise (if parsing fails), the {@code pos} index is left unchanged,
      * the {@code pos} {@linkplain ParsePosition#getErrorIndex() error index} is set to the index of the first
      * unparsable character and an exception is thrown with a similar {@linkplain ParseException#getErrorOffset()
@@ -794,28 +794,28 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
             asString = text.subSequence(start, Math.min(start + READ_AHEAD_LIMIT, length)).toString();
         }
         /*
-         * The Format instances to be used for each ordinate values is determined by the default CRS.
+         * The Format instances to be used for each coordinate values is determined by the default CRS.
          * If no such CRS has been specified, then we will parse everything as plain numbers.
          */
         if (lastCRS != defaultCRS) {
             initialize(defaultCRS);
         }
-        final double[] ordinates;
+        final double[] coordinates;
         Format format;
         final Format[] formats = this.formats;
         if (formats != null) {
             format    = null;
-            ordinates = new double[formats.length];
+            coordinates = new double[formats.length];
         } else {
             format    = getFormat(Number.class);
-            ordinates = new double[DEFAULT_DIMENSION];
+            coordinates = new double[DEFAULT_DIMENSION];
         }
         /*
-         * For each ordinate value except the first one, we need to skip the separator.
+         * For each coordinate value except the first one, we need to skip the separator.
          * If we do not find the separator, we may consider that we reached the coordinate
          * end ahead of time. We currently allow that only for coordinate without CRS.
          */
-        for (int i=0; i < ordinates.length; i++) {
+        for (int i=0; i < coordinates.length; i++) {
             if (i != 0) {
                 final int end = subPos.getIndex();
                 int index = offset + end;
@@ -829,7 +829,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
                     }
                     if (formats == null) {
                         pos.setIndex(index);
-                        return new GeneralDirectPosition(Arrays.copyOf(ordinates, i));
+                        return new GeneralDirectPosition(Arrays.copyOf(coordinates, i));
                     }
                     pos.setIndex(start);
                     pos.setErrorIndex(index);
@@ -839,7 +839,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
                 subPos.setIndex(index + parseSeparator.length() - offset);
             }
             /*
-             * At this point 'subPos' is set to the beginning of the next ordinate to parse in 'asString'.
+             * At this point 'subPos' is set to the beginning of the next coordinate to parse in 'asString'.
              * Parse the value as a number, angle or date, as determined from the coordinate system axis.
              */
             if (formats != null) {
@@ -849,7 +849,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
             final Object object = format.parseObject(asString, subPos);
             if (object == null) {
                 /*
-                 * If we failed to parse, build an error message with the type that was expected for that ordinate.
+                 * If we failed to parse, build an error message with the type that was expected for that coordinate.
                  * If the given CharSequence was not a String, we may need to update the error index since we tried
                  * to parse only a substring.
                  */
@@ -879,7 +879,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
             /*
              * The conversions and sign reversal applied below shall be in exact reverse order than
              * in the 'format(…)' method. However we have one additional step compared to format(…):
-             * the unit written after the ordinate value may not be the same than the unit declared
+             * the unit written after the coordinate value may not be the same than the unit declared
              * in the CRS axis, so we have to parse the unit and convert the value before to apply
              * the reverse of 'format(…)' steps.
              */
@@ -926,9 +926,9 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
             if (isNegative(i)) {
                 value = -value;
             }
-            ordinates[i] = value;
+            coordinates[i] = value;
         }
-        final GeneralDirectPosition position = new GeneralDirectPosition(ordinates);
+        final GeneralDirectPosition position = new GeneralDirectPosition(coordinates);
         position.setCoordinateReferenceSystem(defaultCRS);
         return position;
     }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java
index 442dc9f..367a58f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java
@@ -63,11 +63,11 @@ final class CurveExtremum {
      * Finds the extremum of the unique cubic curve which fit the two given points and derivatives.
      * See class javadoc for more information.
      *
-     * @param  x1   the <var>x</var> ordinate of the first point.
-     * @param  y1   the <var>y</var> ordinate of the first point.
+     * @param  x1   the <var>x</var> coordinate of the first point.
+     * @param  y1   the <var>y</var> coordinate of the first point.
      * @param  dy1  the ∂<var>x</var>/∂<var>y</var> value at the first point.
-     * @param  x2   the <var>x</var> ordinate of the second point.
-     * @param  y2   the <var>y</var> ordinate of the second point.
+     * @param  x2   the <var>x</var> coordinate of the second point.
+     * @param  y2   the <var>y</var> coordinate of the second point.
      * @param  dy2  the ∂<var>x</var>/∂<var>y</var> value at the second point.
      */
     void resolve(double x1, double y1, final double dy1,
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java
index 8a7d41e..653b092 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java
@@ -35,7 +35,7 @@ import static org.apache.sis.util.ArgumentChecks.ensureDimensionMatches;
  * A one-dimensional position within some coordinate reference system.
  *
  * @author  Martin Desruisseaux (IRD, Geomatys)
- * @version 0.3
+ * @version 1.0
  *
  * @see DirectPosition2D
  * @see GeneralDirectPosition
@@ -48,7 +48,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
     /**
      * Serial number for inter-operability with different versions.
      */
-    private static final long serialVersionUID = -9196647508968517838L;
+    private static final long serialVersionUID = -8318842301025970006L;
 
     /**
      * The coordinate reference system for this position;
@@ -56,9 +56,9 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
     private CoordinateReferenceSystem crs;
 
     /**
-     * The ordinate value.
+     * The coordinate value.
      */
-    public double ordinate;
+    public double coordinate;
 
     /**
      * Constructs a position initialized to (0) with a {@code null}
@@ -78,12 +78,12 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
     }
 
     /**
-     * Constructs a 1D position from the specified ordinate.
+     * Constructs a 1D position from the specified coordinate.
      *
-     * @param ordinate  the ordinate value.
+     * @param coordinate  the coordinate value.
      */
-    public DirectPosition1D(final double ordinate) {
-        this.ordinate = ordinate;
+    public DirectPosition1D(final double coordinate) {
+        this.coordinate = coordinate;
     }
 
     /**
@@ -103,13 +103,13 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
      * @see CoordinateFormat
      */
     public DirectPosition1D(final CharSequence wkt) throws IllegalArgumentException {
-        final double[] ordinates = parse(wkt);
-        if (ordinates == null) {
+        final double[] coordinates = parse(wkt);
+        if (coordinates == null) {
             throw new IllegalArgumentException(Errors.format(
                     Errors.Keys.UnparsableStringForClass_2, "POINT", wkt));
         }
-        ensureDimensionMatches("wkt", 1, ordinates);
-        ordinate = ordinates[0];
+        ensureDimensionMatches("wkt", 1, coordinates);
+        coordinate = coordinates[0];
     }
 
     /**
@@ -149,45 +149,45 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
      * Returns a sequence of numbers that hold the coordinate of this position in its reference system.
      *
      * <div class="note"><b>API note:</b>
-     * This method is final for ensuring consistency with the {@link #ordinate} field, which is public.</div>
+     * This method is final for ensuring consistency with the {@link #coordinate} field, which is public.</div>
      *
      * @return the coordinates.
      */
     @Override
     public final double[] getCoordinate() {
-        return new double[] {ordinate};
+        return new double[] {coordinate};
     }
 
     /**
-     * Returns the ordinate at the specified dimension.
+     * Returns the coordinate at the specified dimension.
      *
      * <div class="note"><b>API note:</b>
-     * This method is final for ensuring consistency with the {@link #ordinate} field, which is public.</div>
+     * This method is final for ensuring consistency with the {@link #coordinate} field, which is public.</div>
      *
      * @param  dimension  the dimension, which must be 0.
-     * @return the {@linkplain #ordinate}.
+     * @return the {@link #coordinate}.
      * @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
      */
     @Override
     public final double getOrdinate(final int dimension) throws IndexOutOfBoundsException {
         if (dimension == 0) {
-            return ordinate;
+            return coordinate;
         } else {
             throw new IndexOutOfBoundsException(Errors.format(Errors.Keys.IndexOutOfBounds_1, dimension));
         }
     }
 
     /**
-     * Sets the ordinate value along the specified dimension.
+     * Sets the coordinate value along the specified dimension.
      *
      * @param  dimension  the dimension, which must be 0.
-     * @param  value      the ordinate value.
+     * @param  value      the coordinate value.
      * @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
      */
     @Override
     public void setOrdinate(int dimension, double value) throws IndexOutOfBoundsException {
         if (dimension == 0) {
-            ordinate = value;
+            coordinate = value;
         } else {
             throw new IndexOutOfBoundsException(Errors.format(Errors.Keys.IndexOutOfBounds_1, dimension));
         }
@@ -205,7 +205,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
     public void setLocation(final DirectPosition position) throws MismatchedDimensionException {
         ensureDimensionMatches("position", 1, position);
         setCoordinateReferenceSystem(position.getCoordinateReferenceSystem());
-        ordinate = position.getOrdinate(0);
+        coordinate = position.getOrdinate(0);
     }
 
     /**
@@ -213,7 +213,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
      * The output is like below:
      *
      * {@preformat wkt
-     *   POINT(ordinate)
+     *   POINT(coordinate)
      * }
      *
      * The string returned by this method can be {@linkplain #DirectPosition1D(CharSequence) parsed}
@@ -221,7 +221,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
      */
     @Override
     public String toString() {
-        return toString(this, ordinate == (float) ordinate);
+        return toString(this, coordinate == (float) coordinate);
     }
 
     /**
@@ -244,7 +244,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
      */
     @Override
     public int hashCode() {
-        final int code = 31 + Double.hashCode(ordinate) + Objects.hashCode(crs);
+        final int code = 31 + Double.hashCode(coordinate) + Objects.hashCode(crs);
         assert code == super.hashCode();
         return code;
     }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java
index 8152d6e..5dcd775 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java
@@ -37,7 +37,7 @@ import static org.apache.sis.util.ArgumentChecks.ensureDimensionMatches;
  * <p>This class inherits {@linkplain #x x} and {@linkplain #y y} fields.
  * But despite their names, they don't need to be oriented toward {@linkplain AxisDirection#EAST East} and
  * {@linkplain AxisDirection#NORTH North} respectively. The (<var>x</var>,<var>y</var>) axis can have any
- * direction and should be understood as <cite>ordinate 0</cite> and <cite>ordinate 1</cite> values instead.
+ * direction and should be understood as <cite>coordinate 0</cite> and <cite>coordinate 1</cite> values instead.
  * This is not specific to this implementation; in Java2D too, the visual axis orientation depend
  * on the {@linkplain java.awt.Graphics2D#getTransform() affine transform in the graphics context}.</p>
  *
@@ -97,21 +97,21 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
     }
 
     /**
-     * Constructs a 2D position from the specified ordinates. Despite their names,
+     * Constructs a 2D position from the specified coordinates. Despite their names,
      * the (<var>x</var>,<var>y</var>) coordinates don't need to be oriented toward
      * ({@linkplain AxisDirection#EAST East}, {@linkplain AxisDirection#NORTH North}).
      * Those parameter names simply match the {@linkplain #x x} and {@linkplain #y y} fields.
      * See the <a href="#skip-navbar_top">class javadoc</a> for details.
      *
-     * @param x  the first ordinate value (not necessarily horizontal).
-     * @param y  the second ordinate value (not necessarily vertical).
+     * @param x  the first coordinate value (not necessarily horizontal).
+     * @param y  the second coordinate value (not necessarily vertical).
      */
     public DirectPosition2D(final double x, final double y) {
         super(x, y);
     }
 
     /**
-     * Constructs a 2D position from the specified ordinates in the specified CRS.
+     * Constructs a 2D position from the specified coordinates in the specified CRS.
      * Despite their names, the (<var>x</var>,<var>y</var>) coordinates don't need to be oriented
      * toward ({@linkplain AxisDirection#EAST East}, {@linkplain AxisDirection#NORTH North}).
      * Those parameter names simply match the {@linkplain #x x} and {@linkplain #y y} fields.
@@ -119,8 +119,8 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
      * See the <a href="#skip-navbar_top">class javadoc</a> for details.
      *
      * @param crs  the coordinate reference system, or {@code null}.
-     * @param x    the first ordinate value (not necessarily horizontal).
-     * @param y    the second ordinate value (not necessarily vertical).
+     * @param x    the first coordinate value (not necessarily horizontal).
+     * @param y    the second coordinate value (not necessarily vertical).
      */
     public DirectPosition2D(final CoordinateReferenceSystem crs, final double x, final double y) {
         super(x, y);
@@ -161,14 +161,14 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
      * @see CoordinateFormat
      */
     public DirectPosition2D(final CharSequence wkt) throws IllegalArgumentException {
-        final double[] ordinates = AbstractDirectPosition.parse(wkt);
-        if (ordinates == null) {
+        final double[] coordinates = AbstractDirectPosition.parse(wkt);
+        if (coordinates == null) {
             throw new IllegalArgumentException(Errors.format(
                     Errors.Keys.UnparsableStringForClass_2, "POINT", wkt));
         }
-        ensureDimensionMatches("wkt", 2, ordinates);
-        x = ordinates[0];
-        y = ordinates[1];
+        ensureDimensionMatches("wkt", 2, coordinates);
+        x = coordinates[0];
+        y = coordinates[1];
     }
 
     /**
@@ -227,7 +227,7 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
     }
 
     /**
-     * Returns the ordinate at the specified dimension.
+     * Returns the coordinate at the specified dimension.
      *
      * <div class="note"><b>API note:</b>
      * This method is final for ensuring consistency with the {@code x} and {@code y} fields, which are public.</div>
@@ -246,10 +246,10 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
     }
 
     /**
-     * Sets the ordinate value along the specified dimension.
+     * Sets the coordinate value along the specified dimension.
      *
-     * @param  dimension  the dimension for the ordinate of interest.
-     * @param  value      the ordinate value of interest.
+     * @param  dimension  the dimension for the coordinate of interest.
+     * @param  value      the coordinate value of interest.
      * @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
      */
     @Override
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java
index 8188e29..dc0ac1d 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java
@@ -57,7 +57,7 @@ import static org.apache.sis.geometry.AbstractEnvelope.isNegativeUnsafe;
  * <p>This class inherits {@linkplain #x x} and {@linkplain #y y} fields.
  * But despite their names, they don't need to be oriented toward {@linkplain AxisDirection#EAST East} and
  * {@linkplain AxisDirection#NORTH North} respectively. The (<var>x</var>,<var>y</var>) axis can have any
- * direction and should be understood as <cite>ordinate 0</cite> and <cite>ordinate 1</cite> values instead.
+ * direction and should be understood as <cite>coordinate 0</cite> and <cite>coordinate 1</cite> values instead.
  * This is not specific to this implementation; in Java2D too, the visual axis orientation depend
  * on the {@linkplain java.awt.Graphics2D#getTransform() affine transform in the graphics context}.</p>
  *
@@ -316,8 +316,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * The limits in the direction of decreasing ordinate values for the two dimensions.
-     * This is typically a coordinate position consisting of the minimal ordinates for
+     * The limits in the direction of decreasing coordinate values for the two dimensions.
+     * This is typically a coordinate position consisting of the minimal coordinates for
      * the two dimensions for all points within the {@code Envelope}.
      *
      * <p>The object returned by this method is a copy. Change in the returned position
@@ -331,7 +331,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
      * lower corner longitude greater than the upper corner longitude. Such extended interpretation applies
      * mostly to axes having {@code WRAPAROUND} range meaning.</div>
      *
-     * @return a copy of the lower corner, typically (but not necessarily) containing minimal ordinate values.
+     * @return a copy of the lower corner, typically (but not necessarily) containing minimal coordinate values.
      */
     @Override
     public DirectPosition2D getLowerCorner() {
@@ -339,8 +339,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * The limits in the direction of increasing ordinate values for the two dimensions.
-     * This is typically a coordinate position consisting of the maximal ordinates for
+     * The limits in the direction of increasing coordinate values for the two dimensions.
+     * This is typically a coordinate position consisting of the maximal coordinates for
      * the two dimensions for all points within the {@code Envelope}.
      *
      * <p>The object returned by this method is a copy. Change in the returned position
@@ -354,7 +354,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
      * upper corner longitude less than the lower corner longitude. Such extended interpretation applies
      * mostly to axes having {@code WRAPAROUND} range meaning.</div>
      *
-     * @return a copy of the upper corner, typically (but not necessarily) containing maximal ordinate values.
+     * @return a copy of the upper corner, typically (but not necessarily) containing maximal coordinate values.
      */
     @Override
     public DirectPosition2D getUpperCorner() {
@@ -369,12 +369,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the minimal ordinate along the specified dimension. This method handles
+     * Returns the minimal coordinate along the specified dimension. This method handles
      * anti-meridian spanning as documented in the {@link AbstractEnvelope#getMinimum(int)}
      * method.
      *
      * @param  dimension  the dimension to query.
-     * @return the minimal ordinate value along the given dimension.
+     * @return the minimal coordinate value along the given dimension.
      * @throws IndexOutOfBoundsException if the given index is out of bounds.
      */
     @Override
@@ -393,12 +393,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the maximal ordinate along the specified dimension. This method handles
+     * Returns the maximal coordinate along the specified dimension. This method handles
      * anti-meridian spanning as documented in the {@link AbstractEnvelope#getMaximum(int)}
      * method.
      *
      * @param  dimension  the dimension to query.
-     * @return the maximal ordinate value along the given dimension.
+     * @return the maximal coordinate value along the given dimension.
      * @throws IndexOutOfBoundsException if the given index is out of bounds.
      */
     @Override
@@ -417,12 +417,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the median ordinate along the specified dimension. This method handles
+     * Returns the median coordinate along the specified dimension. This method handles
      * anti-meridian spanning as documented in the {@link AbstractEnvelope#getMedian(int)}
      * method.
      *
      * @param  dimension  the dimension to query.
-     * @return the mid ordinate value along the given dimension.
+     * @return the mid coordinate value along the given dimension.
      * @throws IndexOutOfBoundsException if the given index is out of bounds.
      */
     @Override
@@ -465,12 +465,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     // Do not override getX() and getY() - their default implementations is okay.
 
     /**
-     * Returns the {@linkplain #getMinimum(int) minimal} ordinate value for dimension 0.
+     * Returns the {@linkplain #getMinimum(int) minimal} coordinate value for dimension 0.
      * The default implementation invokes <code>{@linkplain #getMinimum(int) getMinimum}(0)</code>.
      * The result is the standard {@link Rectangle2D} value (namely {@linkplain #x x})
      * only if the envelope is not spanning the anti-meridian.
      *
-     * @return the minimal ordinate value for dimension 0.
+     * @return the minimal coordinate value for dimension 0.
      */
     @Override
     public double getMinX() {
@@ -478,12 +478,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the {@linkplain #getMinimum(int) minimal} ordinate value for dimension 1.
+     * Returns the {@linkplain #getMinimum(int) minimal} coordinate value for dimension 1.
      * The default implementation invokes <code>{@linkplain #getMinimum(int) getMinimum}(1)</code>.
      * The result is the standard {@link Rectangle2D} value (namely {@linkplain #y y})
      * only if the envelope is not spanning the anti-meridian.
      *
-     * @return the minimal ordinate value for dimension 1.
+     * @return the minimal coordinate value for dimension 1.
      */
     @Override
     public double getMinY() {
@@ -491,12 +491,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the {@linkplain #getMaximum(int) maximal} ordinate value for dimension 0.
+     * Returns the {@linkplain #getMaximum(int) maximal} coordinate value for dimension 0.
      * The default implementation invokes <code>{@linkplain #getMaximum(int) getMinimum}(0)</code>.
      * The result is the standard {@link Rectangle2D} value (namely {@linkplain #x x} + {@linkplain #width width})
      * only if the envelope is not spanning the anti-meridian.
      *
-     * @return the maximal ordinate value for dimension 0.
+     * @return the maximal coordinate value for dimension 0.
      */
     @Override
     public double getMaxX() {
@@ -504,12 +504,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the {@linkplain #getMaximum(int) maximal} ordinate value for dimension 1.
+     * Returns the {@linkplain #getMaximum(int) maximal} coordinate value for dimension 1.
      * The default implementation invokes <code>{@linkplain #getMaximum(int) getMinimum}(1)</code>.
      * The result is the standard {@link Rectangle2D} value (namely {@linkplain #y y} + {@linkplain #height height})
      * only if the envelope is not spanning the anti-meridian.
      *
-     * @return the maximal ordinate value for dimension 1.
+     * @return the maximal coordinate value for dimension 1.
      */
     @Override
     public double getMaxY() {
@@ -517,12 +517,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the {@linkplain #getMedian(int) median} ordinate value for dimension 0.
+     * Returns the {@linkplain #getMedian(int) median} coordinate value for dimension 0.
      * The default implementation invokes <code>{@linkplain #getMedian(int) getMedian}(0)</code>.
      * The result is the standard {@link Rectangle2D} value (namely {@linkplain #x x} + {@linkplain #width width}/2)
      * only if the envelope is not spanning the anti-meridian.
      *
-     * @return the median ordinate value for dimension 0.
+     * @return the median coordinate value for dimension 0.
      */
     @Override
     public double getCenterX() {
@@ -530,12 +530,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
     }
 
     /**
-     * Returns the {@linkplain #getMedian(int) median} ordinate value for dimension 1.
+     * Returns the {@linkplain #getMedian(int) median} coordinate value for dimension 1.
      * The default implementation invokes <code>{@linkplain #getMedian(int) getMedian}(1)</code>.
      * The result is the standard {@link Rectangle2D} value (namely {@linkplain #y y} + {@linkplain #height height}/2)
      * only if the envelope is not spanning the anti-meridian.
      *
-     * @return the median ordinate value for dimension 1.
+     * @return the median coordinate value for dimension 1.
      */
     @Override
     public double getCenterY() {
@@ -687,15 +687,15 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
 
     /**
      * Tests if a specified coordinate is inside the boundary of this envelope. If it least one
-     * of the given ordinate value is {@link java.lang.Double#NaN NaN}, then this method returns
+     * of the given coordinate value is {@link java.lang.Double#NaN NaN}, then this method returns
      * {@code false}.
      *
      * <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
      * This method supports anti-meridian spanning in the same way than
      * {@link AbstractEnvelope#contains(DirectPosition)}.
      *
-     * @param  px  the first ordinate value of the point to text.
-     * @param  py  the second ordinate value of the point to text.
+     * @param  px  the first coordinate value of the point to text.
+     * @param  py  the second coordinate value of the point to text.
      * @return {@code true} if the specified coordinate is inside the boundary of this envelope;
      *         {@code false} otherwise.
      */
@@ -744,8 +744,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
      * This method supports anti-meridian spanning in the same way than
      * {@link AbstractEnvelope#contains(Envelope)}.
      *
-     * @param  rx  the <var>x</var> ordinate of the lower corner of the rectangle to test for inclusion.
-     * @param  ry  the <var>y</var> ordinate of the lower corner of the rectangle to test for inclusion.
+     * @param  rx  the <var>x</var> coordinate of the lower corner of the rectangle to test for inclusion.
+     * @param  ry  the <var>y</var> coordinate of the lower corner of the rectangle to test for inclusion.
      * @param  rw  the width of the rectangle to test for inclusion. May be negative if the rectangle spans the anti-meridian.
      * @param  rh  the height of the rectangle to test for inclusion. May be negative.
      * @return {@code true} if this envelope completely encloses the specified one.
@@ -816,8 +816,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
      * This method supports anti-meridian spanning in the same way than
      * {@link AbstractEnvelope#intersects(Envelope)}.
      *
-     * @param  rx  the <var>x</var> ordinate of the lower corner of the rectangle to test for intersection.
-     * @param  ry  the <var>y</var> ordinate of the lower corner of the rectangle to test for intersection.
+     * @param  rx  the <var>x</var> coordinate of the lower corner of the rectangle to test for intersection.
+     * @param  ry  the <var>y</var> coordinate of the lower corner of the rectangle to test for intersection.
      * @param  rw  the width of the rectangle to test for inclusion. May be negative if the rectangle spans the anti-meridian.
      * @param  rh  the height of the rectangle to test for inclusion. May be negative.
      * @return {@code true} if this envelope intersects the specified rectangle.
@@ -897,10 +897,10 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
              */
             if (isSameSign(span0, span1)) {                 // Always 'false' if any value is NaN.
                 if ((min1 > max0 || max1 < min0) && !isNegativeUnsafe(span0)) {
-                    continue;                               // No intersection: leave ordinate values to NaN
+                    continue;                               // No intersection: leave coordinate values to NaN
                 }
             } else if (isNaN(span0) || isNaN(span1)) {
-                continue;                                   // Leave ordinate values to NaN
+                continue;                                   // Leave coordinate values to NaN
             } else {
                 int intersect = 0;                          // A bitmask of intersections (two bits).
                 if (isNegativeUnsafe(span0)) {
@@ -919,7 +919,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
                         min = min1;
                         max = max1;
                     } else {
-                        continue;                           // Leave ordinate values to NaN
+                        continue;                           // Leave coordinate values to NaN
                     }
                 }
             }
@@ -981,13 +981,13 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
             double max = Math.max(max0, max1);
             /*
              * See GeneralEnvelope.add(Envelope) for an explanation of the algorithm applied below.
-             * Note that the "continue" statement has reverse meaning: ordinates are left to NaN.
+             * Note that the "continue" statement has reverse meaning: coordinates are left to NaN.
              */
             final boolean sp0 = isNegative(span0);
             final boolean sp1 = isNegative(span1);
             if (sp0 == sp1) {
                 if (sp0 && !isNegativeUnsafe(max - min)) {
-                    continue;                                   // Leave ordinates to NaN.
+                    continue;                                   // Leave coordinates to NaN.
                 }
             } else if (sp0) {
                 if (max1 <= max0 || min1 >= min0) {
@@ -997,7 +997,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
                     final double left  = min1 - max0;
                     final double right = min0 - max1;
                     if (!(left > 0 || right > 0)) {
-                        continue;                               // Leave ordinates to NaN.
+                        continue;                               // Leave coordinates to NaN.
                     }
                     if (left > right) {min = min1; max = max0;}
                     if (right > left) {min = min0; max = max1;}
@@ -1010,7 +1010,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
                     final double left  = min0 - max1;
                     final double right = min1 - max0;
                     if (!(left > 0 || right > 0)) {
-                        continue;                               // Leave ordinates to NaN.
+                        continue;                               // Leave coordinates to NaN.
                     }
                     if (left > right) {min = min0; max = max1;}
                     if (right > left) {min = min1; max = max0;}
@@ -1044,15 +1044,15 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
      * contains both the original rectangle and the specified point.
      * <p>
      * After adding a point, a call to {@link #contains(double, double)} with the added point
-     * as an argument will return {@code true}, except if one of the point ordinates was
-     * {@link java.lang.Double#NaN} in which case the corresponding ordinate has been ignored.
+     * as an argument will return {@code true}, except if one of the point coordinates was
+     * {@link java.lang.Double#NaN} in which case the corresponding coordinate has been ignored.
      *
      * <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
      * This method supports anti-meridian spanning in the same way than
      * {@link GeneralEnvelope#add(DirectPosition)}.
      *
-     * @param  px  the first ordinate of the point to add.
-     * @param  py  the second ordinate of the point to add.
+     * @param  px  the first coordinate of the point to add.
+     * @param  py  the second coordinate of the point to add.
      */
     @Override
     public void add(final double px, final double py) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
index 71a4530..36177e0 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
@@ -411,11 +411,10 @@ public final class Envelopes extends Static {
                       sourceDim, envelope.getDimension()));
         }
         /*
-         * Allocates all needed objects. The value '3' below is because the following 'while'
-         * loop uses a 'pointIndex' to be interpreted as a number in base 3 (see the comment
-         * inside the loop).  The coordinate to transform must be initialized to the minimal
-         * ordinate values. This coordinate will be updated in the 'switch' statement inside
-         * the 'while' loop.
+         * Allocates all needed objects. The power of 3 below is because the following `while` loop
+         * uses a `pointIndex` to be interpreted as a number in base 3 (see the comment inside the loop).
+         * The coordinate tuple to transform must be initialized to the minimal coordinate values.
+         * This coordinate will be updated in the `switch` statement inside the `while` loop.
          */
         if (sourceDim >= 20) {          // Maximal value supported by Formulas.pow3(int) is 19.
             throw new IllegalArgumentException(Errors.format(Errors.Keys.ExcessiveNumberOfDimensions_1));
@@ -424,15 +423,15 @@ public final class Envelopes extends Static {
         boolean         isDerivativeSupported = true;
         GeneralEnvelope transformed           = null;
         final Matrix[]  derivatives           = new Matrix[Formulas.pow3(sourceDim)];
-        final double[]  ordinates             = new double[derivatives.length * targetDim];
+        final double[]  coordinates           = new double[derivatives.length * targetDim];
         final double[]  sourcePt              = new double[sourceDim];
         for (int i=sourceDim; --i>=0;) {
             sourcePt[i] = envelope.getMinimum(i);
         }
-        // A window over a single coordinate in the 'ordinates' array.
-        final DirectPositionView ordinatesView = new DirectPositionView.Double(ordinates, 0, targetDim);
+        // A window over a single coordinate in the `coordinates` array.
+        final DirectPositionView ordinatesView = new DirectPositionView.Double(coordinates, 0, targetDim);
         /*
-         * Iterates over every minimal, maximal and median ordinate values (3 points) along each
+         * Iterates over every minimal, maximal and median coordinate values (3 points) along each
          * dimension. The total number of iterations is 3 ^ (number of source dimensions).
          */
         transformPoint: while (true) {
@@ -449,13 +448,13 @@ public final class Envelopes extends Static {
             final int offset = pointIndex * targetDim;
             try {
                 derivatives[pointIndex] = derivativeAndTransform(transform,
-                        sourcePt, ordinates, offset, isDerivativeSupported);
+                        sourcePt, coordinates, offset, isDerivativeSupported);
             } catch (TransformException e) {
                 if (!isDerivativeSupported) {
                     throw e;                    // Derivative were already disabled, so something went wrong.
                 }
                 isDerivativeSupported = false;
-                transform.transform(sourcePt, 0, ordinates, offset, 1);
+                transform.transform(sourcePt, 0, coordinates, offset, 1);
                 recoverableException(Envelopes.class, e);       // Log only if the above call was successful.
             }
             /*
@@ -465,7 +464,7 @@ public final class Envelopes extends Static {
             if (transformed == null) {
                 transformed = new GeneralEnvelope(targetDim);
                 for (int i=0; i<targetDim; i++) {
-                    final double value = ordinates[offset + i];
+                    final double value = coordinates[offset + i];
                     transformed.setRange(i, value, value);
                 }
             } else {
@@ -476,7 +475,7 @@ public final class Envelopes extends Static {
              * Get the next point coordinate. The 'coordinateIndex' variable is an index in base 3
              * having a number of digits equals to the number of source dimensions.  For example a
              * 4-D space have indexes ranging from "0000" to "2222" (numbers in base 3). The digits
-             * are then mapped to minimal (0), maximal (1) or central (2) ordinates. The outer loop
+             * are then mapped to minimal (0), maximal (1) or central (2) coordinates. The outer loop
              * stops when the counter roll back to "0000". Note that 'targetPt' must keep the value
              * of the last projected point, which must be the envelope center identified by "2222"
              * in the 4-D case.
@@ -523,8 +522,8 @@ public final class Envelopes extends Static {
                             final int offset1 = targetDim * pointIndex;
                             final int offset2 = targetDim * medianIndex;
                             for (int j=0; j<targetDim; j++) {
-                                extremum.resolve(x1, ordinates[offset1 + j], D1.getElement(j,i),
-                                                 x2, ordinates[offset2 + j], D2.getElement(j,i));
+                                extremum.resolve(x1, coordinates[offset1 + j], D1.getElement(j,i),
+                                                 x2, coordinates[offset2 + j], D2.getElement(j,i));
                                 boolean isP2 = false;
                                 do { // Executed exactly twice, one for each extremum point.
                                     final double x = isP2 ? extremum.ex2 : extremum.ex1;
@@ -541,16 +540,16 @@ public final class Envelopes extends Static {
                                              * on the envelope border which is located vis-à-vis the extremum.
                                              */
                                             for (int ib3 = pointIndex, dim = sourceDim; --dim >= 0; ib3 /= 3) {
-                                                final double ordinate;
+                                                final double coordinate;
                                                 if (dim == i) {
-                                                    ordinate = x;                         // Position of the extremum.
+                                                    coordinate = x;                       // Position of the extremum.
                                                 } else switch (ib3 % 3) {
-                                                    case 0:  ordinate = envelope.getMinimum(dim); break;
-                                                    case 1:  ordinate = envelope.getMaximum(dim); break;
-                                                    case 2:  ordinate = envelope.getMedian (dim); break;
-                                                    default: throw new AssertionError(ib3);     // Should never happen
+                                                    case 0:  coordinate = envelope.getMinimum(dim); break;
+                                                    case 1:  coordinate = envelope.getMaximum(dim); break;
+                                                    case 2:  coordinate = envelope.getMedian (dim); break;
+                                                    default: throw new AssertionError(ib3);     // Should never happen.
                                                 }
-                                                sourcePt[dim] = ordinate;
+                                                sourcePt[dim] = coordinate;
                                             }
                                             temporary = transform.transform(sourceView, temporary);
                                             transformed.add(temporary);
@@ -566,7 +565,7 @@ public final class Envelopes extends Static {
         }
         if (targetPt != null) {
             // Copy the coordinate of the center point.
-            System.arraycopy(ordinates, ordinates.length - targetDim, targetPt, 0, targetDim);
+            System.arraycopy(coordinates, coordinates.length - targetDim, targetPt, 0, targetDim);
         }
         return transformed;
     }
@@ -712,8 +711,8 @@ public final class Envelopes extends Static {
          *
          * 3) If step #2 added the point, iterate over all other axes. If an other bounded axis
          *    is found and that axis is of kind "WRAPAROUND", test for inclusion the same point
-         *    than the point tested at step #1, except for the ordinate of the axis found in this
-         *    step. That ordinate is set to the minimal and maximal values of that axis.
+         *    than the point tested at step #1, except for the coordinate of the axis found in
+         *    this step. That coordinate is set to the minimal and maximal values of that axis.
          *
          *    Example: If the above steps found that the point (90°S, 30°W) need to be included,
          *             then this step #3 will also test the points (90°S, 180°W) and (90°S, 180°E).
@@ -847,7 +846,7 @@ poles:  for (int i=0; i<dimension; i++, dimensionBitMask <<= 1) {
                      */
                     for (int c=0; c<4; c++) {
                         /*
-                         * Set the ordinate value along the axis having the singularity point
+                         * Set the coordinate value along the axis having the singularity point
                          * (cases c=0 and c=2).  If the envelope did not included that point,
                          * then skip completely this case and the next one, i.e. skip c={0,1}
                          * or skip c={2,3}.
@@ -882,7 +881,7 @@ poles:  for (int i=0; i<dimension; i++, dimensionBitMask <<= 1) {
             }
         }
         /*
-         * At this point we finished envelope transformation. Verify if some ordinates need to be "wrapped around"
+         * At this point we finished envelope transformation. Verify if some coordinates need to be "wrapped around"
          * as a result of the coordinate operation.  This is usually the longitude axis where the source CRS uses
          * the [-180 … +180]° range and the target CRS uses the [0 … 360]° range, or the converse. We do not wrap
          * around if the source and target axes use the same range (e.g. the longitude stay [-180 … +180]°) in order
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
index 4a81c2f..b88cb7b 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
@@ -39,7 +39,7 @@ import static org.apache.sis.util.ArgumentChecks.ensureDimensionMatches;
 /**
  * A mutable {@code DirectPosition} (the coordinates of a position) of arbitrary dimension.
  * This particular implementation of {@code DirectPosition} is said "General" because it
- * uses an {@linkplain #ordinates array of ordinates} of an arbitrary length. If the direct
+ * uses an {@link #coordinates array of coordinates} of an arbitrary length. If the direct
  * position is known to be always two-dimensional, then {@link DirectPosition2D} provides
  * a more efficient implementation.
  *
@@ -65,19 +65,27 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
     /**
      * Serial number for inter-operability with different versions.
      */
-    private static final long serialVersionUID = -5524426558018300122L;
+    private static final long serialVersionUID = -1775358214919832302L;
 
     /**
-     * Used for setting the {@link #ordinates} field during a {@link #clone()} operation only.
+     * Used for setting the {@link #coordinates} field during a {@link #clone()} operation only.
      * Will be fetch when first needed.
      */
-    private static volatile Field ordinatesField;
+    private static volatile Field coordinatesField;
 
     /**
-     * The ordinates of the direct position. The length of this array is the
+     * The coordinates of the direct position. The length of this array is the
      * {@linkplain #getDimension() dimension} of this direct position.
      */
-    public final double[] ordinates;
+    public final double[] coordinates;
+
+    /**
+     * @deprecated Renamed {@link #coordinates}.
+     *
+     * @see <a href="https://issues.apache.org/jira/browse/SIS-461">SIS-461</a>
+     */
+    @Deprecated
+    public transient double[] ordinates;
 
     /**
      * The coordinate reference system for this position, or {@code null}.
@@ -102,29 +110,31 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
      * @throws NegativeArraySizeException if {@code dimension} is negative.
      */
     public GeneralDirectPosition(final int dimension) throws NegativeArraySizeException {
-        ordinates = new double[dimension];
+        coordinates = new double[dimension];
+        ordinates = coordinates;
     }
 
     /**
-     * Constructs a position with the specified ordinates.
-     * This constructor assigns the given array directly (without clone) to the {@link #ordinates} field.
+     * Constructs a position with the specified coordinates.
+     * This constructor assigns the given array directly (without clone) to the {@link #coordinates} field.
      * Consequently, callers shall not recycle the same array for creating many instances.
      *
      * <div class="note"><b>Implementation note:</b>
      * the array is not cloned because this is usually not needed, especially in the context of variable
-     * argument lengths since the array is often created implicitly. Furthermore the {@link #ordinates}
+     * argument lengths since the array is often created implicitly. Furthermore the {@link #coordinates}
      * field is public, so cloning the array would not protect the state of this object anyway.</div>
      *
      * <p><b>Caution:</b> if only one number is specified, make sure that the number type is {@code double},
      * {@code float} or {@code long} otherwise the {@link #GeneralDirectPosition(int)} constructor would be
      * invoked with a very different meaning. For example for creating a one-dimensional coordinate initialized
-     * to the ordinate value 100, use <code>new GeneralDirectPosition(100<u>.0</u>)</code>, <strong>not</strong>
+     * to the coordinate value 100, use <code>new GeneralDirectPosition(100<u>.0</u>)</code>, <strong>not</strong>
      * {@code new GeneralDirectPosition(100)}, because the later would actually create a position with 100 dimensions.</p>
      *
-     * @param ordinates  the ordinate values. This array is <strong>not</strong> cloned.
+     * @param coordinates  the coordinate values. This array is <strong>not</strong> cloned.
      */
-    public GeneralDirectPosition(final double... ordinates) {
-        this.ordinates = ordinates;
+    public GeneralDirectPosition(final double... coordinates) {
+        this.coordinates = coordinates;
+        ordinates = coordinates;
     }
 
     /**
@@ -134,9 +144,10 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
      * @param point  the position to copy.
      */
     public GeneralDirectPosition(final DirectPosition point) {
-        ordinates = point.getCoordinate();                              // Should already be cloned.
+        coordinates = point.getCoordinate();                            // Should already be cloned.
         crs = point.getCoordinateReferenceSystem();
-        ensureDimensionMatches("crs", ordinates.length, crs);
+        ensureDimensionMatches("crs", coordinates.length, crs);
+        ordinates = coordinates;
     }
 
     /**
@@ -157,21 +168,22 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
      * @see CoordinateFormat
      */
     public GeneralDirectPosition(final CharSequence wkt) throws IllegalArgumentException {
-        if ((ordinates = parse(wkt)) == null) {
+        if ((coordinates = parse(wkt)) == null) {
             throw new IllegalArgumentException(Errors.format(
                     Errors.Keys.UnparsableStringForClass_2, "POINT", wkt));
         }
+        ordinates = coordinates;
     }
 
     /**
-     * The length of ordinate sequence (the number of entries).
-     * This is always equals to the length of the {@link #ordinates} array.
+     * The length of coordinate sequence (the number of entries).
+     * This is always equals to the length of the {@link #coordinates} array.
      *
      * @return the dimensionality of this position.
      */
     @Override
     public final int getDimension() {
-        return ordinates.length;
+        return coordinates.length;
     }
 
     /**
@@ -203,57 +215,57 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
      * Returns a sequence of numbers that hold the coordinate of this position in its reference system.
      *
      * <div class="note"><b>API note:</b>
-     * This method is final for ensuring consistency with the {@link #ordinates}, array field, which is public.</div>
+     * This method is final for ensuring consistency with the {@link #coordinates}, array field, which is public.</div>
      *
-     * @return a copy of the {@linkplain #ordinates ordinates} array.
+     * @return a copy of the {@link #coordinates coordinates} array.
      */
     @Override
     public final double[] getCoordinate() {
-        return ordinates.clone();
+        return coordinates.clone();
     }
 
     /**
-     * Sets the ordinate values along all dimensions.
+     * Sets the coordinate values along all dimensions.
      *
-     * @param  ordinates  the new ordinates values, or a {@code null} array for
-     *                    setting all ordinate values to {@link Double#NaN NaN}.
+     * @param  coordinates  the new coordinates values, or a {@code null} array for
+     *                      setting all coordinate values to {@link Double#NaN NaN}.
      * @throws MismatchedDimensionException if the length of the specified array is not
      *         equals to the {@linkplain #getDimension() dimension} of this position.
      */
-    public void setCoordinate(final double... ordinates) throws MismatchedDimensionException {
-        if (ordinates == null) {
-            Arrays.fill(this.ordinates, Double.NaN);
+    public void setCoordinate(final double... coordinates) throws MismatchedDimensionException {
+        if (coordinates == null) {
+            Arrays.fill(this.coordinates, Double.NaN);
         } else {
-            ensureDimensionMatches("ordinates", this.ordinates.length, ordinates);
-            System.arraycopy(ordinates, 0, this.ordinates, 0, ordinates.length);
+            ensureDimensionMatches("coordinates", this.coordinates.length, coordinates);
+            System.arraycopy(coordinates, 0, this.coordinates, 0, coordinates.length);
         }
     }
 
     /**
-     * Returns the ordinate at the specified dimension.
+     * Returns the coordinate at the specified dimension.
      *
      * <div class="note"><b>API note:</b>
-     * This method is final for ensuring consistency with the {@link #ordinates}, array field, which is public.</div>
+     * This method is final for ensuring consistency with the {@link #coordinates}, array field, which is public.</div>
      *
      * @param  dimension  the dimension in the range 0 to {@linkplain #getDimension() dimension}-1.
-     * @return the ordinate at the specified dimension.
+     * @return the coordinate at the specified dimension.
      * @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
      */
     @Override
     public final double getOrdinate(final int dimension) throws IndexOutOfBoundsException {
-        return ordinates[dimension];
+        return coordinates[dimension];
     }
 
     /**
-     * Sets the ordinate value along the specified dimension.
+     * Sets the coordinate value along the specified dimension.
      *
-     * @param  dimension  the dimension for the ordinate of interest.
-     * @param  value      the ordinate value of interest.
+     * @param  dimension  the dimension for the coordinate of interest.
+     * @param  value      the coordinate value of interest.
      * @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
      */
     @Override
     public void setOrdinate(final int dimension, final double value) throws IndexOutOfBoundsException {
-        ordinates[dimension] = value;
+        coordinates[dimension] = value;
     }
 
     /**
@@ -262,18 +274,18 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
      * be set to the CRS of the specified position.
      *
      * @param  position  the new position for this point,
-     *                   or {@code null} for setting all ordinate values to {@link Double#NaN NaN}.
+     *                   or {@code null} for setting all coordinate values to {@link Double#NaN NaN}.
      * @throws MismatchedDimensionException if the given position does not have the expected dimension.
      */
     @Override
     public void setLocation(final DirectPosition position) throws MismatchedDimensionException {
         if (position == null) {
-            Arrays.fill(ordinates, Double.NaN);
+            Arrays.fill(coordinates, Double.NaN);
         } else {
-            ensureDimensionMatches("position", ordinates.length, position);
+            ensureDimensionMatches("position", coordinates.length, position);
             setCoordinateReferenceSystem(position.getCoordinateReferenceSystem());
-            for (int i=0; i<ordinates.length; i++) {
-                ordinates[i] = position.getOrdinate(i);
+            for (int i=0; i<coordinates.length; i++) {
+                coordinates[i] = position.getOrdinate(i);
             }
         }
     }
@@ -283,15 +295,15 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
      */
     @Override
     public String toString() {
-        return toString(this, ArraysExt.isSinglePrecision(ordinates));
+        return toString(this, ArraysExt.isSinglePrecision(coordinates));
     }
 
     /**
-     * Returns the {@code "ordinates"} field of the given class and gives write permission to it.
+     * Returns the {@code "coordinates"} field of the given class and gives write permission to it.
      * This method should be invoked only from {@link #clone()} method.
      */
-    static Field getOrdinatesField(final Class<?> type) throws NoSuchFieldException {
-        final Field field = type.getDeclaredField("ordinates");
+    static Field getCoordinatesField(final Class<?> type) throws NoSuchFieldException {
+        final Field field = type.getDeclaredField("coordinates");
         AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
             field.setAccessible(true);
             return null;
@@ -307,27 +319,35 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
     @Override
     public GeneralDirectPosition clone() {
         try {
-            Field field = ordinatesField;
+            Field field = coordinatesField;
             if (field == null) {
-                ordinatesField = field = getOrdinatesField(GeneralDirectPosition.class);
+                coordinatesField = field = getCoordinatesField(GeneralDirectPosition.class);
             }
             GeneralDirectPosition e = (GeneralDirectPosition) super.clone();
-            field.set(e, ordinates.clone());
+            field.set(e, coordinates.clone());
+            e.ordinates = e.coordinates;
             return e;
         } catch (ReflectiveOperationException | CloneNotSupportedException exception) {
-            // Should not happen, since we are cloneable.
-            // Should not happen, since the "ordinates" field exists.
-            // etc...
+            /*
+             * Should not happen, since we are cloneable.
+             * Should not happen, since the "coordinates" field exists.
+             * etc…
+             */
             throw new AssertionError(exception);
         }
     }
 
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        ordinates = coordinates;
+    }
+
     /**
      * {@inheritDoc}
      */
     @Override
     public int hashCode() {
-        final int code = Arrays.hashCode(ordinates) + Objects.hashCode(getCoordinateReferenceSystem());
+        final int code = Arrays.hashCode(coordinates) + Objects.hashCode(getCoordinateReferenceSystem());
         assert code == super.hashCode();
         return code;
     }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java
index f4d7a9b..bd7f9d3 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java
@@ -59,7 +59,7 @@ import static org.apache.sis.math.MathFunctions.isNegativeZero;
  *
  * <p>A {@code GeneralEnvelope} can be created in various ways:</p>
  * <ul>
- *   <li>{@linkplain #GeneralEnvelope(int) From a given number of dimension}, with all ordinates initialized to 0.</li>
+ *   <li>{@linkplain #GeneralEnvelope(int) From a given number of dimension}, with all coordinates initialized to 0.</li>
  *   <li>{@linkplain #GeneralEnvelope(double[], double[]) From two coordinate points}.</li>
  *   <li>{@linkplain #GeneralEnvelope(Envelope) From a an other envelope} (copy constructor).</li>
  *   <li>{@linkplain #GeneralEnvelope(GeographicBoundingBox) From a geographic bounding box}.</li>
@@ -105,7 +105,7 @@ import static org.apache.sis.math.MathFunctions.isNegativeZero;
  *       system axis range meaning} is {@code WRAPAROUND}.</li>
  * </ul>
  *
- * Note that this class does <em>not</em> require the ordinate values to be between the axis minimum and
+ * Note that this class does <em>not</em> require the coordinate values to be between the axis minimum and
  * maximum values. This flexibility exists because out-of-range values happen in practice, while they do
  * not hurt the working of {@code add(…)}, {@code intersect(…)}, {@code contains(…)} and similar methods.
  * This in contrast with the {@code lower > upper} case, which cause the above-cited methods to behave in
@@ -128,20 +128,20 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     private static final long serialVersionUID = 3796799507279068254L;
 
     /**
-     * Used for setting the {@link #ordinates} field during a {@link #clone()} operation only.
+     * Used for setting the {@link #coordinates} field during a {@link #clone()} operation only.
      * Will be fetch when first needed.
      */
-    private static volatile Field ordinatesField;
+    private static volatile Field coordinatesField;
 
     /**
-     * Creates a new envelope using the given array of ordinate values. This constructor stores
+     * Creates a new envelope using the given array of coordinate values. This constructor stores
      * the given reference directly; it does <strong>not</strong> clone the given array. This is
      * the desired behavior for proper working of {@link SubEnvelope}.
      *
-     * @param ordinates  the array of ordinate values to store directly (not cloned).
+     * @param coordinates  the array of coordinate values to store directly (not cloned).
      */
-    GeneralEnvelope(final double[] ordinates) {
-        super(ordinates);
+    GeneralEnvelope(final double[] coordinates) {
+        super(coordinates);
     }
 
     /**
@@ -149,8 +149,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * If at least one corner is associated to a CRS, then the new envelope will also
      * be associated to that CRS.
      *
-     * @param  lowerCorner  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param  upperCorner  the limits in the direction of increasing ordinate values for each dimension.
+     * @param  lowerCorner  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param  upperCorner  the limits in the direction of increasing coordinate values for each dimension.
      * @throws MismatchedDimensionException if the two positions do not have the same dimension.
      * @throws MismatchedReferenceSystemException if the CRS of the two position are not equal.
      */
@@ -161,11 +161,11 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     }
 
     /**
-     * Constructs an envelope defined by two corners given as sequences of ordinate values.
+     * Constructs an envelope defined by two corners given as sequences of coordinate values.
      * The Coordinate Reference System is initially {@code null}.
      *
-     * @param  lowerCorner  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param  upperCorner  the limits in the direction of increasing ordinate values for each dimension.
+     * @param  lowerCorner  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param  upperCorner  the limits in the direction of increasing coordinate values for each dimension.
      * @throws MismatchedDimensionException if the two sequences do not have the same length.
      */
     public GeneralEnvelope(final double[] lowerCorner, final double[] upperCorner) throws MismatchedDimensionException {
@@ -173,7 +173,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     }
 
     /**
-     * Constructs an empty envelope of the specified dimension. All ordinates
+     * Constructs an empty envelope of the specified dimension. All coordinates
      * are initialized to 0 and the coordinate reference system is undefined.
      *
      * @param  dimension  the envelope dimension.
@@ -184,7 +184,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
 
     /**
      * Constructs an empty envelope with the specified coordinate reference system.
-     * All ordinate values are initialized to 0.
+     * All coordinate values are initialized to 0.
      *
      * @param  crs  the coordinate reference system.
      */
@@ -231,8 +231,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * <ul>
      *   <li>Character sequences complying to the rules of Java identifiers are skipped.</li>
      *   <li>Coordinates are separated by a coma ({@code ,}) character.</li>
-     *   <li>The ordinates in a coordinate are separated by a space.</li>
-     *   <li>Ordinate numbers are assumed formatted in US locale.</li>
+     *   <li>The coordinates in a coordinate tuple are separated by a space.</li>
+     *   <li>Coordinate numbers are assumed formatted in US locale.</li>
      *   <li>The coordinate having the highest dimension determines the dimension of this envelope.</li>
      * </ul>
      *
@@ -289,7 +289,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      *
      * @param  crs  the new coordinate reference system, or {@code null}.
      * @throws MismatchedDimensionException if the specified CRS doesn't have the expected number of dimensions.
-     * @throws IllegalStateException if a range of ordinate values in this envelope is compatible with the given CRS.
+     * @throws IllegalStateException if a range of coordinate values in this envelope is compatible with the given CRS.
      *         See <cite>Envelope validation</cite> in class javadoc for more details.
      */
     public void setCoordinateReferenceSystem(final CoordinateReferenceSystem crs)
@@ -298,16 +298,16 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         if (crs != null) {
             ensureDimensionMatches("crs", getDimension(), crs);
             /*
-             * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, ordinates)
-             * except that it may verify only a subset of the ordinate array and throws a different kind
+             * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, coordinates)
+             * except that it may verify only a subset of the coordinate array and throws a different kind
              * of exception in case of failure.
              */
             final int beginIndex = beginIndex();
             final int endIndex = endIndex();
-            final int d = ordinates.length >>> 1;
+            final int d = coordinates.length >>> 1;
             for (int i=beginIndex; i<endIndex; i++) {
-                final double lower = ordinates[i];
-                final double upper = ordinates[i + d];
+                final double lower = coordinates[i];
+                final double upper = coordinates[i + d];
                 if (lower > upper) {
                     final int j = i - beginIndex;
                     if (!isWrapAround(crs, j)) {
@@ -323,8 +323,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * Sets the envelope range along the specified dimension.
      *
      * @param  dimension  the dimension to set.
-     * @param  lower      the limit in the direction of decreasing ordinate values.
-     * @param  upper      the limit in the direction of increasing ordinate values.
+     * @param  lower      the limit in the direction of decreasing coordinate values.
+     * @param  upper      the limit in the direction of increasing coordinate values.
      * @throws IndexOutOfBoundsException if the given index is out of bounds.
      * @throws IllegalArgumentException if {@code lower > upper} and the axis range meaning at the given dimension
      *         is not "wraparound". See <cite>Envelope validation</cite> in class javadoc for more details.
@@ -333,17 +333,17 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     public void setRange(final int dimension, final double lower, final double upper)
             throws IndexOutOfBoundsException
     {
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         ensureValidIndex(d, dimension);
         /*
-         * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, ordinates),
+         * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, coordinates),
          * except that there is no loop.
          */
         if (lower > upper && crs != null && !isWrapAround(crs, dimension)) {
             throw new IllegalArgumentException(illegalRange(crs, dimension, lower, upper));
         }
-        ordinates[dimension + d] = upper;
-        ordinates[dimension]     = lower;
+        coordinates[dimension + d] = upper;
+        coordinates[dimension]     = lower;
     }
 
     /**
@@ -357,20 +357,20 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      *  <var>x</var><sub>max</sub>, <var>y</var><sub>max</sub>, <var>z</var><sub>max</sub>)
      * </div>
      *
-     * @param corners  ordinates of the new lower corner followed by the new upper corner.
+     * @param corners  coordinates of the new lower corner followed by the new upper corner.
      */
     public void setEnvelope(final double... corners) {
-        verifyArrayLength(ordinates.length >>> 1, corners);
+        verifyArrayLength(coordinates.length >>> 1, corners);
         verifyRanges(crs, corners);
-        System.arraycopy(corners, 0, ordinates, 0, ordinates.length);
+        System.arraycopy(corners, 0, coordinates, 0, coordinates.length);
     }
 
     /**
-     * Verifies that the given array of ordinate values has the expected length
+     * Verifies that the given array of coordinate values has the expected length
      * for the given number of dimensions.
      *
      * @param  dimension  the dimension of the envelope.
-     * @param  corners    the user-provided array of ordinate values.
+     * @param  corners    the user-provided array of coordinate values.
      */
     static void verifyArrayLength(final int dimension, final double[] corners) {
         if ((corners.length & 1) != 0) {
@@ -380,7 +380,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         final int d = corners.length >>> 1;
         if (d != dimension) {
             throw new MismatchedDimensionException(Errors.format(
-                    Errors.Keys.MismatchedDimension_3, "ordinates", dimension, d));
+                    Errors.Keys.MismatchedDimension_3, "coordinates", dimension, d));
         }
     }
 
@@ -401,16 +401,16 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         final int beginIndex = beginIndex();
         final int dimension = endIndex() - beginIndex;
         ensureDimensionMatches("envelope", dimension, envelope);
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         if (envelope instanceof ArrayEnvelope) {
             /*
              * Optimization for a common case. This code path is used by Envelopes.compound(…).
              * The main intent is to avoid the creation of temporary DirectPosition objects.
              */
-            final double[] source = ((ArrayEnvelope) envelope).ordinates;
+            final double[] source = ((ArrayEnvelope) envelope).coordinates;
             final int srcOffset = ((ArrayEnvelope) envelope).beginIndex();
-            System.arraycopy(source, srcOffset, ordinates, beginIndex, dimension);
-            System.arraycopy(source, srcOffset + (source.length >>> 1), ordinates, beginIndex + d, dimension);
+            System.arraycopy(source, srcOffset, coordinates, beginIndex, dimension);
+            System.arraycopy(source, srcOffset + (source.length >>> 1), coordinates, beginIndex + d, dimension);
         } else {
             @SuppressWarnings("null")
             final DirectPosition lower = envelope.getLowerCorner();
@@ -418,8 +418,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
             for (int i=0; i<dimension; i++) {
                 final int iLower = beginIndex + i;
                 final int iUpper = iLower + d;
-                ordinates[iLower] = lower.getOrdinate(i);
-                ordinates[iUpper] = upper.getOrdinate(i);
+                coordinates[iLower] = lower.getOrdinate(i);
+                coordinates[iUpper] = upper.getOrdinate(i);
             }
         }
         final CoordinateReferenceSystem envelopeCRS = envelope.getCoordinateReferenceSystem();
@@ -439,20 +439,20 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     public void setToInfinite() {
         final int beginIndex = beginIndex();
         final int endIndex = endIndex();
-        final int d = ordinates.length >>> 1;
-        Arrays.fill(ordinates, beginIndex,   endIndex,   Double.NEGATIVE_INFINITY);
-        Arrays.fill(ordinates, beginIndex+d, endIndex+d, Double.POSITIVE_INFINITY);
+        final int d = coordinates.length >>> 1;
+        Arrays.fill(coordinates, beginIndex,   endIndex,   Double.NEGATIVE_INFINITY);
+        Arrays.fill(coordinates, beginIndex+d, endIndex+d, Double.POSITIVE_INFINITY);
     }
 
     /**
-     * Sets all ordinate values to {@linkplain Double#NaN NaN}.
+     * Sets all coordinate values to {@linkplain Double#NaN NaN}.
      * The {@linkplain #getCoordinateReferenceSystem() coordinate reference system}
      * (if any) stay unchanged.
      *
      * @see #isAllNaN()
      */
     public void setToNaN() {                   // Must be overridden in SubEnvelope
-        Arrays.fill(ordinates, Double.NaN);
+        Arrays.fill(coordinates, Double.NaN);
         assert isAllNaN() : this;
     }
 
@@ -474,11 +474,11 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         ensureNonNull("vector", vector);
         final int beginIndex = beginIndex();
         ensureDimensionMatches("vector", endIndex() - beginIndex, vector);
-        final int upperIndex = beginIndex + (ordinates.length >>> 1);
+        final int upperIndex = beginIndex + (coordinates.length >>> 1);
         for (int i=0; i<vector.length; i++) {
             final double t = vector[i];
-            ordinates[beginIndex + i] += t;
-            ordinates[upperIndex + i] += t;
+            coordinates[beginIndex + i] += t;
+            coordinates[upperIndex + i] += t;
         }
     }
 
@@ -487,15 +487,15 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * This method does not check for anti-meridian spanning. It is invoked only
      * by the {@link Envelopes} transform methods, which build "normal" envelopes.
      *
-     * @param  array   the array which contains the ordinate values.
-     * @param  offset  index of the first valid ordinate value in the given array.
+     * @param  array   the array which contains the coordinate values.
+     * @param  offset  index of the first valid coordinate value in the given array.
      */
     final void addSimple(final double[] array, final int offset) {
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int i=0; i<d; i++) {
             final double value = array[offset + i];
-            if (value < ordinates[i  ]) ordinates[i  ] = value;
-            if (value > ordinates[i+d]) ordinates[i+d] = value;
+            if (value < coordinates[i  ]) coordinates[i  ] = value;
+            if (value > coordinates[i+d]) coordinates[i+d] = value;
         }
     }
 
@@ -505,7 +505,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      *
      * <p>After adding a point, a call to {@link #contains(DirectPosition) contains(DirectPosition)}
      * with the added point as an argument will return {@code true}, except if one of the point
-     * ordinates was {@link Double#NaN} in which case the corresponding ordinate has been ignored.</p>
+     * coordinates was {@link Double#NaN} in which case the corresponding coordinate has been ignored.</p>
      *
      * <div class="section">Pre-conditions</div>
      * This method assumes that the specified point uses the same CRS than this envelope.
@@ -533,16 +533,16 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         final int dimension = endIndex() - beginIndex;
         ensureDimensionMatches("position", dimension, position);
         assert equalsIgnoreMetadata(crs, position.getCoordinateReferenceSystem(), true) : position;
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int i=0; i<dimension; i++) {
             final int iLower = beginIndex + i;
             final int iUpper = iLower + d;
             final double value = position.getOrdinate(i);
-            final double min = ordinates[iLower];
-            final double max = ordinates[iUpper];
+            final double min = coordinates[iLower];
+            final double max = coordinates[iUpper];
             if (!isNegative(max - min)) {                       // Standard case, or NaN.
-                if (value < min) ordinates[iLower] = value;
-                if (value > max) ordinates[iUpper] = value;
+                if (value < min) coordinates[iLower] = value;
+                if (value > max) coordinates[iUpper] = value;
             } else {
                 /*
                  * Spanning the anti-meridian. The [max…min] range (not that min/max are
@@ -565,8 +565,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      *    ─────┘     └─────
      * }
      *
-     * @param  i      the dimension of the ordinate
-     * @param  value  the ordinate value to add to this envelope.
+     * @param  i      the dimension of the coordinate
+     * @param  value  the coordinate value to add to this envelope.
      * @param  left   the border on the left side,  which is the <em>max</em> value (yes, this is confusing!)
      * @param  right  the border on the right side, which is the <em>min</em> value (yes, this is confusing!)
      */
@@ -576,9 +576,9 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
             right -= value;
             if (right > 0) {
                 if (right > left) {
-                    i += (ordinates.length >>> 1);
+                    i += (coordinates.length >>> 1);
                 }
-                ordinates[i] = value;
+                coordinates[i] = value;
             }
         }
     }
@@ -594,7 +594,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
      * This method supports envelopes spanning the anti-meridian. If one or both envelopes span
      * the anti-meridian, then the result of the {@code add} operation may be an envelope expanding
-     * to infinities. In such case, the ordinate range will be either [−∞…∞] or [0…−0] depending on
+     * to infinities. In such case, the coordinate range will be either [−∞…∞] or [0…−0] depending on
      * whatever the original range span the anti-meridian or not.
      *
      * @param  envelope  the {@code Envelope} to add to this envelope.
@@ -612,12 +612,12 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         assert equalsIgnoreMetadata(crs, envelope.getCoordinateReferenceSystem(), true) : envelope;
         final DirectPosition lower = envelope.getLowerCorner();
         final DirectPosition upper = envelope.getUpperCorner();
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int i=0; i<dimension; i++) {
             final int iLower = beginIndex + i;
             final int iUpper = iLower + d;
-            final double min0 = ordinates[iLower];
-            final double max0 = ordinates[iUpper];
+            final double min0 = coordinates[iLower];
+            final double max0 = coordinates[iUpper];
             final double min1 = lower.getOrdinate(i);
             final double max1 = upper.getOrdinate(i);
             final boolean sp0 = isNegative(max0 - min0);
@@ -637,9 +637,9 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                  *    ──┘ │  │ └──          ────┼──┼─┘└─
                  *    ────┘  └────          ────┘  └────
                  */
-                if (min1 < min0) ordinates[iLower] = min1;
-                if (max1 > max0) ordinates[iUpper] = max1;
-                if (!sp0 || isNegativeUnsafe(ordinates[iUpper] - ordinates[iLower])) {
+                if (min1 < min0) coordinates[iLower] = min1;
+                if (max1 > max0) coordinates[iUpper] = max1;
+                if (!sp0 || isNegativeUnsafe(coordinates[iUpper] - coordinates[iLower])) {
                     continue;               // We are done, go to the next dimension.
                 }
                 // If we were spanning the anti-meridian before the union but
@@ -672,8 +672,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                 if (left > 0 || right > 0) {
                     // The < and > checks below are not completly redundant.
                     // The difference is when a value is NaN.
-                    if (left > right) ordinates[iLower] = min1;
-                    if (right > left) ordinates[iUpper] = max1;     // This is the case illustrated above.
+                    if (left > right) coordinates[iLower] = min1;
+                    if (right > left) coordinates[iUpper] = max1;     // This is the case illustrated above.
                     continue;                                       // We are done, go to the next dimension.
                 }
                 // If we reach this point, the given envelope fills completly the "exclusion area"
@@ -685,15 +685,15 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                  * given envelope spans to infinities.
                  */
                 if (max0 <= max1 || min0 >= min1) {
-                    ordinates[iLower] = min1;
-                    ordinates[iUpper] = max1;
+                    coordinates[iLower] = min1;
+                    coordinates[iUpper] = max1;
                     continue;
                 }
                 final double left  = min0 - max1;
                 final double right = min1 - max0;
                 if (left > 0 || right > 0) {
-                    if (left > right) ordinates[iUpper] = max1;
-                    if (right > left) ordinates[iLower] = min1;
+                    if (left > right) coordinates[iUpper] = max1;
+                    if (right > left) coordinates[iLower] = min1;
                     continue;
                 }
             }
@@ -703,11 +703,11 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
              * the "normal" / "anti-meridian spanning" state.
              */
             if (sp0) {
-                ordinates[iLower] = +0.0;
-                ordinates[iUpper] = -0.0;
+                coordinates[iLower] = +0.0;
+                coordinates[iUpper] = -0.0;
             } else {
-                ordinates[iLower] = Double.NEGATIVE_INFINITY;
-                ordinates[iUpper] = Double.POSITIVE_INFINITY;
+                coordinates[iLower] = Double.NEGATIVE_INFINITY;
+                coordinates[iUpper] = Double.POSITIVE_INFINITY;
             }
         }
         assert contains(envelope) || isEmpty() || hasNaN(envelope) : this;
@@ -738,12 +738,12 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
         assert equalsIgnoreMetadata(crs, envelope.getCoordinateReferenceSystem(), true) : envelope;
         final DirectPosition lower = envelope.getLowerCorner();
         final DirectPosition upper = envelope.getUpperCorner();
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int i=beginIndex; i<dimension; i++) {
             final int iLower = beginIndex + i;
             final int iUpper = iLower + d;
-            final double min0  = ordinates[iLower];
-            final double max0  = ordinates[iUpper];
+            final double min0  = coordinates[iLower];
+            final double max0  = coordinates[iUpper];
             final double min1  = lower.getOrdinate(i);
             final double max1  = upper.getOrdinate(i);
             final double span0 = max0 - min0;
@@ -760,19 +760,19 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                     /*
                      * The check for !isNegative(span0) is because if both envelopes span the
                      * anti-merdian, then there is always an intersection on both side no matter
-                     * what envelope ordinates are because both envelopes extend toward infinities:
+                     * what envelope coordinates are because both envelopes extend toward infinities:
                      *     ────┐  ┌────            ────┐  ┌────
                      *     ──┐ │  │ ┌──     or     ────┼──┼─┐┌─
                      *     ──┘ │  │ └──            ────┼──┼─┘└─
                      *     ────┘  └────            ────┘  └────
                      * Since we excluded the above case, entering in this block means that the
-                     * envelopes are "normal" and do not intersect, so we set ordinates to NaN.
+                     * envelopes are "normal" and do not intersect, so we set coordinates to NaN.
                      *   ┌────┐
                      *   │    │     ┌────┐
                      *   │    │     └────┘
                      *   └────┘
                      */
-                    ordinates[iLower] = ordinates[iUpper] = Double.NaN;
+                    coordinates[iLower] = coordinates[iUpper] = Double.NaN;
                     continue;
                 }
             } else {
@@ -787,18 +787,18 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                          *       └─┼────┘ │                     └────┘  │  │
                          *    ─────┘      └─────              ──────────┘  └─────
                          */
-                        if (min1 <= max0) {intersect  = 1; ordinates[iLower] = min1;}
-                        if (max1 >= min0) {intersect |= 2; ordinates[iUpper] = max1;}
+                        if (min1 <= max0) {intersect  = 1; coordinates[iLower] = min1;}
+                        if (max1 >= min0) {intersect |= 2; coordinates[iUpper] = max1;}
                     } else {
                         // Same than above, but with indices 0 and 1 interchanged.
-                        // No need to set ordinate values since they would be the same.
+                        // No need to set coordinate values since they would be the same.
                         if (min0 <= max1) {intersect  = 1;}
                         if (max0 >= min1) {intersect |= 2;}
                     }
                 }
                 /*
                  * Cases 0 and 3 are illustrated below. In case 1 and 2, we will set
-                 * only the ordinate value which has not been set by the above code.
+                 * only the coordinate value which has not been set by the above code.
                  *
                  *                [intersect=0]          [intersect=3]
                  *              ─────┐     ┌─────      ─────┐     ┌─────
@@ -813,8 +813,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                  */
                 switch (intersect) {
                     default: throw new AssertionError(intersect);
-                    case 1: if (max1 < max0) ordinates[iUpper] = max1; break;
-                    case 2: if (min1 > min0) ordinates[iLower] = min1; break;
+                    case 1: if (max1 < max0) coordinates[iUpper] = max1; break;
+                    case 2: if (min1 > min0) coordinates[iLower] = min1; break;
                     case 3: // Fall through
                     case 0: {
                         /*
@@ -833,15 +833,15 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                             min = Double.NaN;
                             max = Double.NaN;
                         }
-                        ordinates[iLower] = min;
-                        ordinates[iUpper] = max;
+                        coordinates[iLower] = min;
+                        coordinates[iUpper] = max;
                         break;
                     }
                 }
                 continue;
             }
-            if (min1 > min0) ordinates[iLower] = min1;
-            if (max1 < max0) ordinates[iUpper] = max1;
+            if (min1 > min0) coordinates[iLower] = min1;
+            if (max1 < max0) coordinates[iUpper] = max1;
         }
         // Tests only if the interection result is non-empty.
         assert isEmpty() || AbstractEnvelope.castOrCopy(envelope).contains(this) : this;
@@ -849,19 +849,19 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
 
     /**
      * Ensures that the envelope is contained in the coordinate system domain.
-     * For each dimension, this method compares the ordinate values against the
+     * For each dimension, this method compares the coordinate values against the
      * limits of the coordinate system axis for that dimension.
-     * If some ordinates are out of range, then there is a choice depending on the
+     * If some coordinates are out of range, then there is a choice depending on the
      * {@linkplain CoordinateSystemAxis#getRangeMeaning() axis range meaning}:
      *
      * <ul class="verbose">
-     *   <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> ordinates), then values
+     *   <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> coordinates), then values
      *       greater than the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximal value}
      *       are replaced by the axis maximum, and values smaller than the
      *       {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimal value}
      *       are replaced by the axis minimum.</li>
      *
-     *   <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> ordinates), then
+     *   <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> coordinates), then
      *       a multiple of the axis range (e.g. 360° for longitudes) is added or subtracted.
      *       Example:
      *       <ul>
@@ -874,7 +874,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      *
      * <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
      * If the envelope is spanning the anti-meridian, then some {@linkplain #getLower(int) lower}
-     * ordinate values may become greater than their {@linkplain #getUpper(int) upper} counterpart
+     * coordinate values may become greater than their {@linkplain #getUpper(int) upper} counterpart
      * as a result of this method call. If such effect is undesirable, then this method may be
      * combined with {@link #simplify()} as below:
      *
@@ -895,7 +895,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * or {@linkplain #intersect(Envelope) intersection} of envelopes, in order to ensure that
      * both envelopes are defined in the same domain. This method may also be invoked before
      * to project an envelope, since some projections produce {@link Double#NaN} numbers when
-     * given an ordinate value out of bounds.
+     * given an coordinate value out of bounds.
      *
      * @return {@code true} if this envelope has been modified as a result of this method call,
      *         or {@code false} if no change has been done.
@@ -913,17 +913,17 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     /**
      * Normalizes only the dimensions returned by the given iterator, or all dimensions if the iterator is null.
      * This is used for normalizing the result of a coordinate operation where a wrap around axis does not
-     * necessarily means that the ordinates need to be normalized along that axis.
+     * necessarily means that the coordinates need to be normalized along that axis.
      *
      * @param  cs          the coordinate system of this envelope CRS (as an argument because sometime already known).
-     * @param  beginIndex  index of the first ordinate value in {@link #ordinates} array. Non-zero for sub-envelopes.
+     * @param  beginIndex  index of the first coordinate value in {@link #coordinates} array. Non-zero for sub-envelopes.
      * @param  count       number of coordinates, i.e. this envelope dimensions.
      * @param  dimensions  the dimensions to check for normalization, or {@code null} for all dimensions.
      * @return {@code true} if this envelope has been modified as a result of this method call.
      */
     final boolean normalize(final CoordinateSystem cs, final int beginIndex, final int count, final Iterator<Integer> dimensions) {
         boolean changed = false;
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int j=0; j<count; j++) {
             final int i = (dimensions != null) ? dimensions.next() : j;
             final int iLower = beginIndex + i;
@@ -933,13 +933,13 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
             final double  maximum = axis.getMaximumValue();
             final RangeMeaning rm = axis.getRangeMeaning();
             if (RangeMeaning.EXACT.equals(rm)) {
-                if (ordinates[iLower] < minimum) {ordinates[iLower] = minimum; changed = true;}
-                if (ordinates[iUpper] > maximum) {ordinates[iUpper] = maximum; changed = true;}
+                if (coordinates[iLower] < minimum) {coordinates[iLower] = minimum; changed = true;}
+                if (coordinates[iUpper] > maximum) {coordinates[iUpper] = maximum; changed = true;}
             } else if (RangeMeaning.WRAPAROUND.equals(rm)) {
                 final double csSpan = maximum - minimum;
                 if (csSpan > 0 && csSpan < Double.POSITIVE_INFINITY) {
-                    double o1 = ordinates[iLower];
-                    double o2 = ordinates[iUpper];
+                    double o1 = coordinates[iLower];
+                    double o2 = coordinates[iUpper];
                     if (Math.abs(o2-o1) >= csSpan) {
                         /*
                          * If the range exceed the CS span, then we have to replace it by the
@@ -952,19 +952,19 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
                          */
                         if (o1 != minimum || o2 != maximum) {
                             if ((o1 % csSpan) == 0 && (o2 % csSpan) == 0) {
-                                ordinates[iLower] = +0.0;
-                                ordinates[iUpper] = -0.0;
+                                coordinates[iLower] = +0.0;
+                                coordinates[iUpper] = -0.0;
                             } else {
-                                ordinates[iLower] = minimum;
-                                ordinates[iUpper] = maximum;
+                                coordinates[iLower] = minimum;
+                                coordinates[iUpper] = maximum;
                             }
                             changed = true;
                         }
                     } else {
                         o1 = Math.floor((o1 - minimum) / csSpan) * csSpan;
                         o2 = Math.floor((o2 - minimum) / csSpan) * csSpan;
-                        if (o1 != 0) {ordinates[iLower] -= o1; changed = true;}
-                        if (o2 != 0) {ordinates[iUpper] -= o2; changed = true;}
+                        if (o1 != 0) {coordinates[iLower] -= o1; changed = true;}
+                        if (o2 != 0) {coordinates[iUpper] -= o2; changed = true;}
                     }
                 }
             }
@@ -974,13 +974,13 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
 
     /**
      * Ensures that <var>lower</var> ≦ <var>upper</var> for every dimensions.
-     * If a {@linkplain #getUpper(int) upper ordinate value} is less than a
-     * {@linkplain #getLower(int) lower ordinate value}, then there is a choice:
+     * If a {@linkplain #getUpper(int) upper coordinate value} is less than a
+     * {@linkplain #getLower(int) lower coordinate value}, then there is a choice:
      *
      * <ul>
      *   <li>If the axis has {@link RangeMeaning#WRAPAROUND}, then:<ul>
-     *       <li>the lower ordinate value is set to the {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimum value}, and</li>
-     *       <li>the upper ordinate value is set to the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximum value}.</li>
+     *       <li>the lower coordinate value is set to the {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimum value}, and</li>
+     *       <li>the upper coordinate value is set to the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximum value}.</li>
      *     </ul></li>
      *   <li>Otherwise an {@link IllegalStateException} is thrown.</li>
      * </ul>
@@ -990,29 +990,29 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      *
      * @return {@code true} if this envelope has been modified as a result of this method call,
      *         or {@code false} if no change has been done.
-     * @throws IllegalStateException if a upper ordinate value is less than a lower ordinate
+     * @throws IllegalStateException if a upper coordinate value is less than a lower coordinate
      *         value on an axis which does not have the {@code WRAPAROUND} range meaning.
      *
      * @see #toSimpleEnvelopes()
      */
     public boolean simplify() throws IllegalStateException {
         boolean changed = false;
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         final int beginIndex = beginIndex();
         final int dimension = endIndex() - beginIndex;
         for (int i=0; i<dimension; i++) {
             final int iLower = beginIndex + i;
             final int iUpper = iLower + d;
-            final double lower = ordinates[iLower];
-            final double upper = ordinates[iUpper];
+            final double lower = coordinates[iLower];
+            final double upper = coordinates[iUpper];
             if (isNegative(upper - lower)) {                            // Use 'isNegative' for catching [+0 … -0] range.
                 final CoordinateSystemAxis axis = getAxis(crs, i);
                 if (isWrapAround(axis)) {
-                    ordinates[iLower] = axis.getMinimumValue();
-                    ordinates[iUpper] = axis.getMaximumValue();
+                    coordinates[iLower] = axis.getMinimumValue();
+                    coordinates[iUpper] = axis.getMaximumValue();
                     changed = true;
                 } else {
-                    throw new IllegalStateException(Errors.format(Errors.Keys.IllegalOrdinateRange_3,
+                    throw new IllegalStateException(Errors.format(Errors.Keys.IllegalCoordinateRange_3,
                             lower, upper, (axis != null) ? axis.getName() : i));
                 }
             }
@@ -1042,8 +1042,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      * This method does not compute a sub-CRS because it may not be needed, or the sub-CRS may be already
      * known by the caller.
      *
-     * @param  beginIndex  the index of the first valid ordinate value of the corners.
-     * @param  endIndex    the index after the last valid ordinate value of the corners.
+     * @param  beginIndex  the index of the first valid coordinate value of the corners.
+     * @param  endIndex    the index after the last valid coordinate value of the corners.
      * @return the sub-envelope of dimension {@code endIndex - beginIndex}.
      * @throws IndexOutOfBoundsException if an index is out of bounds.
      *
@@ -1051,8 +1051,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
      */
     // Must be overridden in SubEnvelope
     public GeneralEnvelope subEnvelope(final int beginIndex, final int endIndex) throws IndexOutOfBoundsException {
-        ensureValidIndexRange(ordinates.length >>> 1, beginIndex, endIndex);
-        return new SubEnvelope(ordinates, beginIndex, endIndex);
+        ensureValidIndexRange(coordinates.length >>> 1, beginIndex, endIndex);
+        return new SubEnvelope(coordinates, beginIndex, endIndex);
         /*
          * Do not check if we could return "this" as an optimization, in order to keep
          * the method contract simpler (i.e. the returned envelope CRS is always null).
@@ -1067,12 +1067,12 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
     @Override
     public GeneralEnvelope clone() {
         try {
-            Field field = ordinatesField;
+            Field field = coordinatesField;
             if (field == null) {
-                ordinatesField = field = GeneralDirectPosition.getOrdinatesField(ArrayEnvelope.class);
+                coordinatesField = field = GeneralDirectPosition.getCoordinatesField(ArrayEnvelope.class);
             }
             GeneralEnvelope e = (GeneralEnvelope) super.clone();
-            field.set(e, ordinates.clone());
+            field.set(e, coordinates.clone());
             return e;
         } catch (CloneNotSupportedException | ReflectiveOperationException exception) {
             /*
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java
index e546d5f..e2384e6 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java
@@ -57,8 +57,8 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
      * Constructs an envelope defined by two corners given as direct positions.
      * The envelope CRS will be the CRS of the given positions.
      *
-     * @param  lowerCorner  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param  upperCorner  the limits in the direction of increasing ordinate values for each dimension.
+     * @param  lowerCorner  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param  upperCorner  the limits in the direction of increasing coordinate values for each dimension.
      * @throws MismatchedDimensionException if the two positions do not have the same dimension.
      * @throws MismatchedReferenceSystemException if the CRS of the two position are not equal.
      */
@@ -69,10 +69,10 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
     }
 
     /**
-     * Constructs an envelope defined by two corners given as sequences of ordinate values.
+     * Constructs an envelope defined by two corners given as sequences of coordinate values.
      *
-     * @param  lowerCorner  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param  upperCorner  the limits in the direction of increasing ordinate values for each dimension.
+     * @param  lowerCorner  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param  upperCorner  the limits in the direction of increasing coordinate values for each dimension.
      * @param  crs          the CRS to assign to this envelope, or {@code null}.
      * @throws MismatchedDimensionException if the two sequences do not have the same length, or
      *         if the dimension of the given CRS is not equals to the dimension of the given corners.
@@ -112,7 +112,7 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
     }
 
     /**
-     * Creates an immutable envelope with the ordinate values of the given envelope but
+     * Creates an immutable envelope with the coordinate values of the given envelope but
      * a different CRS. This method does <strong>not</strong> reproject the given envelope.
      * It just assign the given CRS to this envelope without any check, except for the CRS
      * dimension.
@@ -121,7 +121,7 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
      * copy has a null CRS.</p>
      *
      * @param  crs       the CRS to assign to this envelope, or {@code null}.
-     * @param  envelope  the envelope from which to copy ordinate values.
+     * @param  envelope  the envelope from which to copy coordinate values.
      * @throws MismatchedDimensionException if the dimension of the given CRS is not equals
      *         to the dimension of the given envelope.
      */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java
index d88b9da..a2ee98e 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java
@@ -203,8 +203,8 @@ public final class Shapes2D extends Static {
         double ymax = Double.NEGATIVE_INFINITY;
         /*
          * Notation (as if we were applying a map projection, but this is not necessarily the case):
-         *   - (λ,φ) are ordinate values before projection.
-         *   - (x,y) are ordinate values after projection.
+         *   - (λ,φ) are coordinate values before projection.
+         *   - (x,y) are coordinate values after projection.
          *   - D[00|01|10|11] are the ∂x/∂λ, ∂x/∂φ, ∂y/∂λ and ∂y/∂φ derivatives respectively.
          *   - Variables with indice 0 are for the very first point in iteration order.
          *   - Variables with indice 1 are for the values of the previous iteration.
@@ -280,8 +280,8 @@ public final class Shapes2D extends Static {
              * to use the information provided by derivatives at those points, if available.
              * For the following block, notation is:
              *
-             *   - s  are ordinate values in the source space (λ or φ)
-             *   - t  are ordinate values in the target space (x or y)
+             *   - s  are coordinate values in the source space (λ or φ)
+             *   - t  are coordinate values in the target space (x or y)
              *
              * They are not necessarily in the same dimension. For example would could have
              * s=λ while t=y. This is typically the case when inspecting the top or bottom
@@ -292,7 +292,7 @@ public final class Shapes2D extends Static {
              */
             if (D1 != null && D2 != null) {
                 final int srcDim;
-                final double s1, s2;                // Ordinate values in source space (before projection)
+                final double s1, s2;                // Coordinate values in source space (before projection)
                 switch (i) {
                     case 1: case 2: case 5: case 6: {assert φ2==φ1; srcDim=0; s1=λ1; s2=λ2; break;}     // Horizontal segment
                     case 3: case 4: case 7: case 8: {assert λ2==λ1; srcDim=1; s1=φ1; s2=φ2; break;}     // Vertical segment
@@ -309,7 +309,7 @@ public final class Shapes2D extends Static {
                      * At this point we found the extremum of the projected line segment
                      * using a cubic curve t = A + Bs + Cs² + Ds³ approximation.  Before
                      * to add those extremum into the projected bounding box, we need to
-                     * ensure that the source ordinate is inside the the original
+                     * ensure that the source coordinate is inside the the original
                      * (unprojected) bounding box.
                      */
                     boolean isP2 = false;
@@ -574,8 +574,8 @@ public final class Shapes2D extends Static {
             }
         }
         /*
-         * At this point we finished envelope transformation. Verify if some ordinates need to be "wrapped around"
-         * as a result of the coordinate operation.   This is usually the longitude axis where the source CRS uses
+         * At this point we finished envelope transformation. Verify if some coordinates need to be "wrapped around"
+         * as a result of the coordinate operation. This is usually the longitude axis where the source CRS uses
          * the [-180 … +180]° range and the target CRS uses the [0 … 360]° range, or the converse. In such case we
          * set the rectangle to the full range (we do not use the mechanism documented in Envelope2D) because most
          * Rectangle2D implementations do not support spanning the anti-meridian. This results in larger rectangle
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java
index 511cbd3..7b586d7 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java
@@ -44,14 +44,14 @@ final class SubEnvelope extends GeneralEnvelope {
     private static final long serialVersionUID = 7241242611077979466L;
 
     /**
-     * The index of the first valid ordinate value of the lower corner in the {@link #ordinates} array.
+     * The index of the first valid coordinate value of the lower corner in the {@link #coordinates} array.
      *
      * @see ArrayEnvelope#beginIndex()
      */
     private final int beginIndex;
 
     /**
-     * The index after the last valid ordinate value of the lower corner  in the {@link #ordinates} array.
+     * The index after the last valid coordinate value of the lower corner  in the {@link #coordinates} array.
      *
      * @see ArrayEnvelope#endIndex()
      */
@@ -62,18 +62,18 @@ final class SubEnvelope extends GeneralEnvelope {
      * reference directly; it does <strong>not</strong> clone the given array. This is the desired
      * behavior for allowing the {@code SubEnvelope} view to be "live".
      *
-     * @param ordinates   the array of ordinate values to store directly (not cloned).
-     * @param beginIndex  the index of the first valid ordinate value of the lower corner in the ordinates array.
-     * @param endIndex    the index after the last valid ordinate value of the lower corner in the ordinates array.
+     * @param coordinates   the array of coordinate values to store directly (not cloned).
+     * @param beginIndex    the index of the first valid coordinate value of the lower corner in the coordinates array.
+     * @param endIndex      the index after the last valid coordinate value of the lower corner in the coordinates array.
      */
-    SubEnvelope(final double[] ordinates, final int beginIndex, final int endIndex) {
-        super(ordinates);
+    SubEnvelope(final double[] coordinates, final int beginIndex, final int endIndex) {
+        super(coordinates);
         this.beginIndex = beginIndex;
         this.endIndex = endIndex;
     }
 
     /**
-     * Returns the index of the first valid ordinate value of the lower corner in the ordinates array.
+     * Returns the index of the first valid coordinate value of the lower corner in the coordinates array.
      * This information is used by super-class methods.
      */
     @Override
@@ -82,7 +82,7 @@ final class SubEnvelope extends GeneralEnvelope {
     }
 
     /**
-     * Returns the index after the last valid ordinate value of the lower corner in the ordinates array.
+     * Returns the index after the last valid coordinate value of the lower corner in the coordinates array.
      * This information is used by super-class methods.
      */
     @Override
@@ -105,7 +105,7 @@ final class SubEnvelope extends GeneralEnvelope {
     @Override
     public double getLower(final int dimension) throws IndexOutOfBoundsException {
         ensureValidIndex(endIndex, dimension);
-        return ordinates[dimension + beginIndex];
+        return coordinates[dimension + beginIndex];
     }
 
     /**
@@ -115,7 +115,7 @@ final class SubEnvelope extends GeneralEnvelope {
     @Override
     public double getUpper(final int dimension) throws IndexOutOfBoundsException {
         ensureValidIndex(endIndex, dimension);
-        return ordinates[dimension + beginIndex + (ordinates.length >>> 1)];
+        return coordinates[dimension + beginIndex + (coordinates.length >>> 1)];
     }
 
     /**
@@ -128,14 +128,14 @@ final class SubEnvelope extends GeneralEnvelope {
         ensureValidIndex(endIndex, dimension);
         /*
          * The check performed here shall be identical to the super-class method, which is itself
-         * identical to ArrayEnvelope.verifyRanges(crs, ordinates) except that there is no loop.
+         * identical to ArrayEnvelope.verifyRanges(crs, coordinates) except that there is no loop.
          */
         if (lower > upper && crs != null && !isWrapAround(crs, dimension)) {
             throw new IllegalArgumentException(illegalRange(crs, dimension, lower, upper));
         }
         dimension += beginIndex;
-        ordinates[dimension + (ordinates.length >>> 1)] = upper;
-        ordinates[dimension] = lower;
+        coordinates[dimension + (coordinates.length >>> 1)] = upper;
+        coordinates[dimension] = lower;
     }
 
     /**
@@ -146,9 +146,9 @@ final class SubEnvelope extends GeneralEnvelope {
         final int dimension = getDimension();
         verifyArrayLength(dimension, corners);
         verifyRanges(crs, corners);
-        final int d = ordinates.length >>> 1;
-        System.arraycopy(corners, 0,         ordinates, beginIndex,     dimension);
-        System.arraycopy(corners, dimension, ordinates, beginIndex + d, dimension);
+        final int d = coordinates.length >>> 1;
+        System.arraycopy(corners, 0,         coordinates, beginIndex,     dimension);
+        System.arraycopy(corners, dimension, coordinates, beginIndex + d, dimension);
     }
 
     /**
@@ -156,9 +156,9 @@ final class SubEnvelope extends GeneralEnvelope {
      */
     @Override
     public boolean isAllNaN() {
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         for (int i=beginIndex; i<endIndex; i++) {
-            if (!Double.isNaN(ordinates[i]) || !Double.isNaN(ordinates[i+d])) {
+            if (!Double.isNaN(coordinates[i]) || !Double.isNaN(coordinates[i+d])) {
                 return false;
             }
         }
@@ -171,9 +171,9 @@ final class SubEnvelope extends GeneralEnvelope {
      */
     @Override
     public void setToNaN() {
-        final int d = ordinates.length >>> 1;
-        Arrays.fill(ordinates, beginIndex,   endIndex,   Double.NaN);
-        Arrays.fill(ordinates, beginIndex+d, endIndex+d, Double.NaN);
+        final int d = coordinates.length >>> 1;
+        Arrays.fill(coordinates, beginIndex,   endIndex,   Double.NaN);
+        Arrays.fill(coordinates, beginIndex+d, endIndex+d, Double.NaN);
         assert isAllNaN() : this;
     }
 
@@ -200,20 +200,20 @@ final class SubEnvelope extends GeneralEnvelope {
     @Override
     public GeneralEnvelope subEnvelope(final int b, final int e) throws IndexOutOfBoundsException {
         ensureValidIndexRange(endIndex - beginIndex, b, e);
-        return new SubEnvelope(ordinates, b + beginIndex, e + beginIndex);
+        return new SubEnvelope(coordinates, b + beginIndex, e + beginIndex);
     }
 
     /**
-     * If the user wants a clone, copy only the relevant part of the ordinates array.
+     * If the user wants a clone, copy only the relevant part of the coordinates array.
      */
     @Override
     @SuppressWarnings("CloneDoesntCallSuperClone")
     public GeneralEnvelope clone() {
-        final int d = ordinates.length >>> 1;
+        final int d = coordinates.length >>> 1;
         final int dimension = endIndex - beginIndex;
         final GeneralEnvelope copy = new GeneralEnvelope(endIndex - beginIndex);
-        System.arraycopy(ordinates, beginIndex,     copy.ordinates, 0,         dimension);
-        System.arraycopy(ordinates, beginIndex + d, copy.ordinates, dimension, dimension);
+        System.arraycopy(coordinates, beginIndex,     copy.coordinates, 0,         dimension);
+        System.arraycopy(coordinates, beginIndex + d, copy.coordinates, dimension, dimension);
         copy.crs = crs;
         return copy;
     }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java
index c983b78..8bd3a8f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java
@@ -69,7 +69,7 @@
  * <center><img src="doc-files/AntiMeridian.png" alt="Envelope spannning the anti-meridian"></center>
  *
  * In SIS, every envelopes defined in this package support the extended bounding box interpretation:
- * for any dimension, ordinate values such that <var>upper</var> &lt; <var>lower</var> are handled
+ * for any dimension, coordinate values such that <var>upper</var> &lt; <var>lower</var> are handled
  * in a special way. This handling is slightly different for two groups of methods:
  *
  * <ul>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java
index 7d82422..4327a87 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java
@@ -192,7 +192,7 @@ public final class CoordinateOperations extends SystemListener {
     }
 
     /**
-     * Returns the packed indices of target dimensions where ordinate values may need to be wrapped around.
+     * Returns the packed indices of target dimensions where coordinate values may need to be wrapped around.
      * This method matches target coordinate system axes having {@link RangeMeaning#WRAPAROUND} with source
      * axes, then verifies if the range of values changed (taking unit conversions in account). A target
      * dimension {@code i} may need to "wrap around" the coordinate values if the {@code 1 << i} bit is set.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java
index 7bdf5e4..a9f9ec0 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java
@@ -35,21 +35,21 @@ import org.opengis.geometry.UnmodifiableGeometryException;
  */
 public abstract class DirectPositionView extends AbstractDirectPosition {
     /**
-     * The index of the first value in the ordinates array.
+     * The index of the first value in the coordinates array.
      * This field is non-final in order to allow the caller to move the view over an array of coordinates.
      */
     public int offset;
 
     /**
-     * The number of valid ordinate values.
+     * The number of valid coordinate values.
      */
     final int dimension;
 
     /**
      * Creates a new direct position wrapping the given array.
      *
-     * @param  offset     the first value index in the ordinates array.
-     * @param  dimension  the number of valid ordinate values.
+     * @param  offset     the first value index in the coordinates array.
+     * @param  dimension  the number of valid coordinate values.
      */
     DirectPositionView(final int offset, final int dimension) {
         this.offset    = offset;
@@ -92,54 +92,54 @@ public abstract class DirectPositionView extends AbstractDirectPosition {
      */
     public static final class Double extends DirectPositionView {
         /**
-         * The ordinate values. This is a direct reference to the array given to the constructor.
+         * The coordinate values. This is a direct reference to the array given to the constructor.
          * The length of this array may be greater then the number of dimensions.
          */
-        private final double[] ordinates;
+        private final double[] coordinates;
 
         /**
          * Creates a new direct position wrapping the given array.
          *
-         * @param  ordinates  the ordinate values.
+         * @param  coordinates  the coordinate values.
          */
-        public Double(final double[] ordinates) {
-            super(0, ordinates.length);
-            this.ordinates = ordinates;
+        public Double(final double[] coordinates) {
+            super(0, coordinates.length);
+            this.coordinates = coordinates;
         }
 
         /**
          * Creates a new direct position wrapping the given array.
          *
-         * @param  ordinates  the ordinate values.
-         * @param  offset     the first value index in the ordinates array.
-         * @param  dimension  the number of valid ordinate values.
+         * @param  coordinates  the coordinate values.
+         * @param  offset     the first value index in the coordinates array.
+         * @param  dimension  the number of valid coordinate values.
          */
-        public Double(final double[] ordinates, final int offset, final int dimension) {
+        public Double(final double[] coordinates, final int offset, final int dimension) {
             super(offset, dimension);
-            this.ordinates = ordinates;
+            this.coordinates = coordinates;
         }
 
         /**
-         * Returns the ordinate at the given index.
+         * Returns the coordinate at the given index.
          * <strong>This implementation does not check index validity</strong>, unless assertions are enabled.
          *
-         * @param  dim  the dimension of the ordinate to get fetch.
+         * @param  dim  the dimension of the coordinate to get fetch.
          * @return the coordinate value at the given dimension.
          */
         @Override
         public double getOrdinate(final int dim) {
             assert dim >= 0 && dim < dimension : dim;
-            return ordinates[offset + dim];
+            return coordinates[offset + dim];
         }
 
         /**
-         * Returns all ordinate values.
+         * Returns all coordinate values.
          *
          * @return all coordinate values.
          */
         @Override
         public double[] getCoordinate() {
-            return Arrays.copyOfRange(ordinates, offset, offset + dimension);
+            return Arrays.copyOfRange(coordinates, offset, offset + dimension);
         }
     }
 
@@ -148,34 +148,34 @@ public abstract class DirectPositionView extends AbstractDirectPosition {
      */
     public static final class Float extends DirectPositionView {
         /**
-         * The ordinate values. This is a direct reference to the array given to the constructor.
+         * The coordinate values. This is a direct reference to the array given to the constructor.
          * The length of this array may be greater then the number of dimensions.
          */
-        private final float[] ordinates;
+        private final float[] coordinates;
 
         /**
          * Creates a new direct position wrapping the given array.
          *
-         * @param  ordinates  the ordinate values.
-         * @param  offset     the first value index in the ordinates array.
-         * @param  dimension  the number of valid ordinate values.
+         * @param  coordinates  the coordinate values.
+         * @param  offset     the first value index in the coordinates array.
+         * @param  dimension  the number of valid coordinate values.
          */
-        public Float(final float[] ordinates, final int offset, final int dimension) {
+        public Float(final float[] coordinates, final int offset, final int dimension) {
             super(offset, dimension);
-            this.ordinates = ordinates;
+            this.coordinates = coordinates;
         }
 
         /**
-         * Returns the ordinate at the given index.
+         * Returns the coordinate at the given index.
          * <strong>This implementation does not check index validity</strong>, unless assertions are enabled.
          *
-         * @param  dim  the dimension of the ordinate to get fetch.
+         * @param  dim  the dimension of the coordinate to get fetch.
          * @return the coordinate value at the given dimension.
          */
         @Override
         public double getOrdinate(final int dim) {
             assert dim >= 0 && dim < dimension : dim;
-            return ordinates[offset + dim];
+            return coordinates[offset + dim];
         }
     }
 }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java
index aeea24b..9c12b04 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java
@@ -24,7 +24,7 @@ import org.apache.sis.internal.util.CollectionsExt;
 
 /**
  * The domain of values of an EPSG parameter which accepts different units.
- * An example is the EPSG:8617 (<cite>Ordinate 1 of evaluation point</cite>) parameter,
+ * An example is the EPSG:8617 (<cite>Coordinate 1 of evaluation point</cite>) parameter,
  * which may be used in the EPSG database with either metres or degrees units.
  *
  * @author  Martin Desruisseaux (Geomatys)
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
index 95f8fb0..9c145a2 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
@@ -39,7 +39,7 @@ import static org.apache.sis.internal.metadata.ReferencingServices.NAUTICAL_MILE
  */
 public final class Formulas extends Static {
     /**
-     * Default tolerance threshold for comparing ordinate values in a projected CRS,
+     * Default tolerance threshold for comparing coordinate values in a projected CRS,
      * assuming that the unit of measurement is metre. This constant determines also
      * (indirectly) the minimum accuracy of iterative methods in map projections.
      *
@@ -49,7 +49,7 @@ public final class Formulas extends Static {
     public static final double LINEAR_TOLERANCE = 0.01;
 
     /**
-     * Default tolerance threshold for comparing ordinate values in a geographic CRS,
+     * Default tolerance threshold for comparing coordinate values in a geographic CRS,
      * assuming that the unit of measurement is decimal degrees and using the standard
      * nautical mile length.
      *
@@ -61,7 +61,7 @@ public final class Formulas extends Static {
     public static final double ANGULAR_TOLERANCE = LINEAR_TOLERANCE / (NAUTICAL_MILE * 60);
 
     /**
-     * Default tolerance threshold for comparing ordinate values in temporal CRS,
+     * Default tolerance threshold for comparing coordinate values in temporal CRS,
      * assuming that the unit of measurement is second. Current value is arbitrary
      * and may change in any future Apache SIS version.
      */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java
index 6ad5976..ba51d6d 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java
@@ -263,6 +263,6 @@ public final class PositionTransformer extends GeneralDirectPosition {
      * @throws TransformException if a coordinate transformation was required and failed.
      */
     public Matrix inverseTransform(final double[] target) throws TransformException {
-        return MathTransforms.derivativeAndTransform(inverse(), ordinates, 0, target, 0);
+        return MathTransforms.derivativeAndTransform(inverse(), coordinates, 0, target, 0);
     }
 }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java
index 839177b..f5e455d 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java
@@ -326,7 +326,7 @@ public final class ServicesForMetadata extends ReferencingServices {
 
     /**
      * Sets a vertical extent with the value inferred from the given envelope.
-     * Only the vertical ordinates are extracted; all other ordinates are ignored.
+     * Only the vertical coordinates are extracted; all other coordinates are ignored.
      *
      * @param  envelope  the source envelope.
      * @param  target    the target vertical extent where to store envelope information.
@@ -344,7 +344,7 @@ public final class ServicesForMetadata extends ReferencingServices {
 
     /**
      * Sets a temporal extent with the value inferred from the given envelope.
-     * Only the vertical ordinates are extracted; all other ordinates are ignored.
+     * Only the vertical coordinates are extracted; all other coordinates are ignored.
      *
      * @param  envelope  the source envelope.
      * @param  target    the target temporal extent where to store envelope information.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java
index 620e314..346222a 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java
@@ -59,10 +59,10 @@ import org.apache.sis.internal.util.Strings;
  */
 @SuppressWarnings("CloneableClassWithoutClone")
 public class IntervalRectangle extends Rectangle2D {
-    /** Minimal <var>x</var> ordinate value. */ public double xmin;
-    /** Minimal <var>y</var> ordinate value. */ public double ymin;
-    /** Maximal <var>x</var> ordinate value. */ public double xmax;
-    /** Maximal <var>y</var> ordinate value. */ public double ymax;
+    /** Minimal <var>x</var> coordinate value. */ public double xmin;
+    /** Minimal <var>y</var> coordinate value. */ public double ymin;
+    /** Maximal <var>x</var> coordinate value. */ public double xmax;
+    /** Maximal <var>y</var> coordinate value. */ public double ymax;
 
     /**
      * Constructs a default rectangle initialized to {@code (0,0,0,0)}.
@@ -97,14 +97,14 @@ public class IntervalRectangle extends Rectangle2D {
 
     /**
      * Constructs a rectangle initialized to the two first dimensions of the given corners.
-     * This constructor unconditionally assigns {@code lower} ordinates to {@link #xmin}, {@link #ymin} and
-     * {@code upper} ordinates to {@link #xmax}, {@link #ymax} regardless of their values; this constructor
-     * does not verify if {@code lower} ordinates are smaller than {@code upper} ordinates.
+     * This constructor unconditionally assigns {@code lower} coordinates to {@link #xmin}, {@link #ymin} and
+     * {@code upper} coordinates to {@link #xmax}, {@link #ymax} regardless of their values; this constructor
+     * does not verify if {@code lower} coordinates are smaller than {@code upper} coordinates.
      * This is sometime useful for creating a rectangle spanning the anti-meridian,
      * even if {@code IntervalRectangle} class does not support such rectangles by itself.
      *
-     * @param lower  the limits in the direction of decreasing ordinate values for each dimension.
-     * @param upper  the limits in the direction of increasing ordinate values for each dimension.
+     * @param lower  the limits in the direction of decreasing coordinate values for each dimension.
+     * @param upper  the limits in the direction of increasing coordinate values for each dimension.
      *
      * @see Envelope#getLowerCorner()
      * @see Envelope#getUpperCorner()
@@ -120,10 +120,10 @@ public class IntervalRectangle extends Rectangle2D {
      * Creates a rectangle using maximal <var>x</var> and <var>y</var> values rather than width and height.
      * This constructor avoid the problem of NaN values when extremum are infinite numbers.
      *
-     * @param xmin  minimal <var>x</var> ordinate value.
-     * @param ymin  minimal <var>y</var> ordinate value.
-     * @param xmax  maximal <var>x</var> ordinate value.
-     * @param ymax  maximal <var>y</var> ordinate value.
+     * @param xmin  minimal <var>x</var> coordinate value.
+     * @param ymin  minimal <var>y</var> coordinate value.
+     * @param xmax  maximal <var>x</var> coordinate value.
+     * @param ymax  maximal <var>y</var> coordinate value.
      */
     public IntervalRectangle(final double xmin, final double ymin, final double xmax, final double ymax) {
         this.xmin = xmin;
@@ -144,9 +144,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the minimal <var>x</var> ordinate value.
+     * Returns the minimal <var>x</var> coordinate value.
      *
-     * @return the minimal <var>x</var> ordinate value.
+     * @return the minimal <var>x</var> coordinate value.
      */
     @Override
     public final double getX() {
@@ -154,9 +154,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the minimal <var>y</var> ordinate value.
+     * Returns the minimal <var>y</var> coordinate value.
      *
-     * @return the minimal <var>y</var> ordinate value.
+     * @return the minimal <var>y</var> coordinate value.
      */
     @Override
     public final double getY() {
@@ -186,9 +186,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the minimal <var>x</var> ordinate value.
+     * Returns the minimal <var>x</var> coordinate value.
      *
-     * @return the minimal <var>x</var> ordinate value.
+     * @return the minimal <var>x</var> coordinate value.
      */
     @Override
     public final double getMinX() {
@@ -196,9 +196,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the minimal <var>y</var> ordinate value.
+     * Returns the minimal <var>y</var> coordinate value.
      *
-     * @return the minimal <var>y</var> ordinate value.
+     * @return the minimal <var>y</var> coordinate value.
      */
     @Override
     public final double getMinY() {
@@ -206,9 +206,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the maximal <var>x</var> ordinate value.
+     * Returns the maximal <var>x</var> coordinate value.
      *
-     * @return the maximal <var>x</var> ordinate value.
+     * @return the maximal <var>x</var> coordinate value.
      */
     @Override
     public final double getMaxX() {
@@ -216,9 +216,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the maximal <var>y</var> ordinate value.
+     * Returns the maximal <var>y</var> coordinate value.
      *
-     * @return the maximal <var>y</var> ordinate value.
+     * @return the maximal <var>y</var> coordinate value.
      */
     @Override
     public final double getMaxY() {
@@ -226,9 +226,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the <var>x</var> ordinate of the center of the rectangle.
+     * Returns the <var>x</var> coordinate of the center of the rectangle.
      *
-     * @return the median <var>x</var> ordinate value.
+     * @return the median <var>x</var> coordinate value.
      */
     @Override
     public final double getCenterX() {
@@ -236,9 +236,9 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the <var>y</var> ordinate of the center of the rectangle.
+     * Returns the <var>y</var> coordinate of the center of the rectangle.
      *
-     * @return the median <var>y</var> ordinate value.
+     * @return the median <var>y</var> coordinate value.
      */
     @Override
     public final double getCenterY() {
@@ -248,8 +248,8 @@ public class IntervalRectangle extends Rectangle2D {
     /**
      * Sets the location and size of this rectangle to the specified values.
      *
-     * @param  x       the <var>x</var> minimal ordinate value.
-     * @param  y       the <var>y</var> minimal ordinate value.
+     * @param  x       the <var>x</var> minimal coordinate value.
+     * @param  y       the <var>y</var> minimal coordinate value.
      * @param  width   the rectangle width.
      * @param  height  the rectangle height.
      */
@@ -292,8 +292,8 @@ public class IntervalRectangle extends Rectangle2D {
      * The edges are considered exclusive; this method returns {@code false} if the two rectangles just touch to each
      * other.
      *
-     * @param  x       the <var>x</var> minimal ordinate value.
-     * @param  y       the <var>y</var> minimal ordinate value.
+     * @param  x       the <var>x</var> minimal coordinate value.
+     * @param  y       the <var>y</var> minimal coordinate value.
      * @param  width   the rectangle width.
      * @param  height  the rectangle height.
      * @return {@code true} if this rectangle intersects the interior of the specified set of rectangular coordinates.
@@ -331,8 +331,8 @@ public class IntervalRectangle extends Rectangle2D {
     /**
      * Tests if the interior of this rectangle entirely contains the specified set of rectangular coordinates.
      *
-     * @param  x       the <var>x</var> minimal ordinate value.
-     * @param  y       the <var>y</var> minimal ordinate value.
+     * @param  x       the <var>x</var> minimal coordinate value.
+     * @param  y       the <var>y</var> minimal coordinate value.
      * @param  width   the rectangle width.
      * @param  height  the rectangle height.
      * @return {@code true} if this rectangle entirely contains specified set of rectangular coordinates.
@@ -476,8 +476,8 @@ public class IntervalRectangle extends Rectangle2D {
      * added point falls on the left or bottom edge of the enlarged rectangle, {@code contains}
      * returns {@code false} for that point.</p>
      *
-     * @param  x  x ordinate value of the point to add.
-     * @param  y  y ordinate value of the point to add.
+     * @param  x  x coordinate value of the point to add.
+     * @param  y  y coordinate value of the point to add.
      */
     @Override
     public final void add(final double x, final double y) {
@@ -503,7 +503,7 @@ public class IntervalRectangle extends Rectangle2D {
     }
 
     /**
-     * Returns the {@code String} representation of this {@code Rectangle2D}. The ordinate order is
+     * Returns the {@code String} representation of this {@code Rectangle2D}. The coordinate order is
      * (<var>x</var><sub>min</sub>, <var>y</var><sub>min</sub>, <var>x</var><sub>max</sub>, <var>y</var><sub>max</sub>),
      * which is consistent with the {@link #IntervalRectangle(double, double, double, double)} constructor
      * and with the {@code BBOX} <cite>Well Known Text</cite> (WKT) syntax.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java b/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java
index cde64bc..2e95ee4 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java
@@ -334,7 +334,7 @@ final class Verifier {
     /**
      * If the given domain of values accepts units of incompatible dimensions, return the unit which is compatible
      * with the given units. This is a non-public mechanism handling a few parameters in the EPSG database, like
-     * <cite>Ordinate 1 of evaluation point</cite> (EPSG:8617).
+     * <cite>Coordinate 1 of evaluation point</cite> (EPSG:8617).
      */
     private static Unit<?> getCompatibleUnit(final Range<?> valueDomain, final Unit<?> unit) {
         if (valueDomain instanceof EPSGParameterDomain) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java
index 410c7b6..d5a4cd5 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java
@@ -233,9 +233,9 @@ public enum AxesConvention implements AxisFilter {
     },
 
     /**
-     * Axes are ordered for a <cite>right-handed</cite> coordinate system. Axis directions, ranges or ordinate values
-     * and units of measurement are unchanged. In the two-dimensional case, the handedness is defined from the point
-     * of view of an observer above the plane of the system.
+     * Axes are ordered for a <cite>right-handed</cite> coordinate system. Axis directions, ranges or coordinate values
+     * and units of measurement are unchanged. In the two-dimensional case, the handedness is defined from the point of
+     * view of an observer above the plane of the system.
      *
      * <p>Note that a right-handed coordinate system does not guarantee that longitude or <var>x</var> axis
      * will be first in every cases. The most notable exception is the case of (West, North) orientations.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java
index 47541c7..fed9355 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java
@@ -432,11 +432,11 @@ public class DefaultCoordinateSystemAxis extends AbstractIdentifiedObject implem
     }
 
     /**
-     * Returns the unit of measure used for this coordinate system axis. If this {@code CoordinateSystemAxis}
-     * was given by <code>{@link AbstractCS#getAxis(int) CoordinateSystem.getAxis}(i)</code>, then all ordinate
+     * Returns the unit of measure used for this coordinate system axis. If this {@code CoordinateSystemAxis} was
+     * given by <code>{@link AbstractCS#getAxis(int) CoordinateSystem.getAxis}(i)</code>, then all coordinate
      * values at dimension <var>i</var> in a coordinate tuple shall be recorded using this unit of measure.
      *
-     * @return the unit of measure used for ordinate values along this coordinate system axis.
+     * @return the unit of measure used for coordinate values along this coordinate system axis.
      */
     @Override
     @XmlAttribute(name= "uom", required = true)
@@ -627,7 +627,7 @@ public class DefaultCoordinateSystemAxis extends AbstractIdentifiedObject implem
         /*
          * At this point the comparison is in "ignore metadata" mode. We compare the axis range
          * only if the range meaning is "wraparound" for both axes, because only in such case a
-         * coordinate operation may shift some ordinate values (typically ±360° on longitudes).
+         * coordinate operation may shift some coordinate values (typically ±360° on longitudes).
          */
         final CoordinateSystemAxis that = (CoordinateSystemAxis) object;
         if (!equalsIgnoreMetadata(that, mode, RangeMeaning.WRAPAROUND.equals(this.getRangeMeaning()) &&
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java
index 62c144b..9b186ee 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java
@@ -29,7 +29,7 @@ import org.apache.sis.measure.Units;
 
 /**
  * A 1-dimensional coordinate system for points that lie on a single axis (not necessarily a straight line).
- * Ordinate values are distances from the axis origin to the point along the axis.
+ * Coordinate values are distances from the axis origin to the point along the axis.
  * A typical example is an axis for representing the points along a road.
  *
  * <table class="sis">
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java
index fc5b5e2..6a7106f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java
@@ -378,9 +378,9 @@ final class Normalizer implements Comparable<Normalizer> {
      *
      * <p>This method shifts the axis {@linkplain CoordinateSystemAxis#getMinimumValue() minimum} and
      * {@linkplain CoordinateSystemAxis#getMaximumValue() maximum} values by a multiple of half the range
-     * (typically 180°). This method does not change the meaning of ordinate values. For example a longitude
-     * of -60° still locate the same point in the old and the new coordinate system. But the preferred way
-     * to locate that point become the 300° value if the longitude range has been shifted to positive values.</p>
+     * (typically 180°). This method does not change the meaning of coordinate values. For example a longitude
+     * of -60° still locate the same point in the old and the new coordinate system. But the preferred way to
+     * locate that point become the 300° value if the longitude range has been shifted to positive values.</p>
      *
      * @return a coordinate system using the given kind of longitude range, or {@code null} if no change is needed.
      */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
index e98c4b0..0a363f6 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
@@ -609,7 +609,7 @@ public class DefaultEllipsoid extends AbstractIdentifiedObject implements Ellips
         if (abs(φ1) <= COMPARISON_THRESHOLD && abs(φ2) <= COMPARISON_THRESHOLD) {
             return abs(λ1-λ2) * getSemiMajorAxis(); // Points are on the equator.
         }
-        // At least one input ordinate is NaN.
+        // At least one input coordinate is NaN.
         if (isNaN(λ1) || isNaN(φ1) || isNaN(λ2) || isNaN(φ2)) {
             return NaN;
         }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
index f5fdebe..f895aff 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
@@ -2527,7 +2527,7 @@ codes:  for (int i=0; i<codes.length; i++) {
                  * Search for units.   We typically have many different units but all of the same dimension
                  * (for example metres, kilometres, feet, etc.). In such case, the units Set will have only
                  * one element and that element will be the most frequently used unit.  But some parameters
-                 * accept units of different dimensions.   For example the "Ordinate 1 of evaluation point"
+                 * accept units of different dimensions. For example the "Coordinate 1 of evaluation point"
                  * (EPSG:8617) parameter value may be in metres or in degrees.   In such case the units Set
                  * will have two elements.
                  */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java
index c421576..691f8ca 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java
@@ -321,12 +321,12 @@ public class AbstractCoordinateOperation extends AbstractIdentifiedObject implem
      *     target dimension}, minus the dimension of the {@code interpolationCRS} (if any).</li>
      * </ul>
      *
-     * If the {@code interpolationCRS} is non-null, then the given {@code transform} shall expect input ordinates
+     * If the {@code interpolationCRS} is non-null, then the given {@code transform} shall expect input coordinates
      * in the following order:
      *
      * <ol>
-     *   <li>Ordinates of the interpolation CRS. Example: (<var>x</var>,<var>y</var>) in a vertical transform.</li>
-     *   <li>Ordinates of the source CRS. Example: (<var>z</var>) in a vertical transform.</li>
+     *   <li>Coordinates of the interpolation CRS. Example: (<var>x</var>,<var>y</var>) in a vertical transform.</li>
+     *   <li>Coordinates of the source CRS. Example: (<var>z</var>) in a vertical transform.</li>
      * </ol>
      *
      * The math transform shall let the interpolation coordinates {@linkplain DefaultPassThroughOperation pass through
@@ -664,7 +664,7 @@ check:      for (int isTarget=0; ; isTarget++) {        // 0 == source check; 1
      * <div class="section">Use with interpolation CRS</div>
      * If the {@linkplain #getInterpolationCRS() interpolation CRS} is non-null, then the math transform
      * input coordinates shall by (<var>interpolation</var>, <var>source</var>) tuples: for each value
-     * to transform, the interpolation point ordinates shall be first, followed by the source coordinates.
+     * to transform, the interpolation point coordinates shall be first, followed by the source coordinates.
      *
      * <div class="note"><b>Example:</b>
      * in a transformation between two {@linkplain org.apache.sis.referencing.crs.DefaultVerticalCRS vertical CRS},
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
index 0ec2e3f..1944f8f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
@@ -899,8 +899,8 @@ public class CoordinateOperationFinder extends CoordinateOperationRegistry {
         final CoordinateReferenceSystem[] stepComponents = new CoordinateReferenceSystem[infos.length];
         /*
          * Operations found are stored in 'infos', but are not yet wrapped in PassThroughOperations.
-         * We need to know first if some ordinate values need reordering for matching the target CRS
-         * order. We also need to know if any source ordinates should be dropped.
+         * We need to know first if some coordinate values need reordering for matching the target CRS
+         * order. We also need to know if any source coordinates should be dropped.
          */
         for (int i=0; i<infos.length; i++) {
             if ((infos[i] = SubOperationInfo.create(this, sourceIsUsed, sourceComponents, targetComponents.get(i))) == null) {
@@ -975,7 +975,7 @@ public class CoordinateOperationFinder extends CoordinateOperationRegistry {
             final int startAtDimension = endAtDimension;
             endAtDimension += delta;
             /*
-             * Constructs the pass through transform only if there is at least one ordinate to pass.
+             * Constructs the pass through transform only if there is at least one coordinate to pass.
              * Actually the code below would work inconditionally, but we perform this check anyway
              * for avoiding the creation of intermediate objects.
              */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java
index 9decaff..c493207 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java
@@ -336,23 +336,23 @@ public class DefaultPassThroughOperation extends AbstractCoordinateOperation imp
     /**
      * Invoked by JAXB at unmarshalling time for setting the modified coordinates.
      */
-    private void setIndices(final int[] ordinates) {
+    private void setIndices(final int[] coordinates) {
         String missing = "sourceCRS";
         final CoordinateReferenceSystem sourceCRS = super.getSourceCRS();
         if (sourceCRS != null) {
             missing = "modifiedCoordinate";
-            if (ordinates != null && ordinates.length != 0) {
+            if (coordinates != null && coordinates.length != 0) {
                 missing = "coordOperation";
                 if (operation != null) {
-                    for (int i=1; i<ordinates.length; i++) {
-                        final int previous = ordinates[i-1];
-                        if (previous < 1 || ordinates[i] != previous + 1) {
+                    for (int i=1; i<coordinates.length; i++) {
+                        final int previous = coordinates[i-1];
+                        if (previous < 1 || coordinates[i] != previous + 1) {
                             throw new IllegalArgumentException(Errors.format(
-                                    Errors.Keys.CanNotAssign_2, missing, Arrays.toString(ordinates)));
+                                    Errors.Keys.CanNotAssign_2, missing, Arrays.toString(coordinates)));
                         }
                     }
-                    transform = MathTransforms.passThrough(ordinates[0] - 1, operation.getMathTransform(),
-                            ReferencingUtilities.getDimension(sourceCRS) - ordinates[ordinates.length - 1]);
+                    transform = MathTransforms.passThrough(coordinates[0] - 1, operation.getMathTransform(),
+                            ReferencingUtilities.getDimension(sourceCRS) - coordinates[coordinates.length - 1]);
                     return;
                 }
             }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java
index cb1844c..df4d943 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java
@@ -254,8 +254,8 @@ public final class Matrices extends Static {
         /*
          * Maps source axes to destination axes. If no axis is moved (for example if the user
          * want to transform (NORTH,EAST) to (SOUTH,EAST)), then source and destination index
-         * will be equal.   If some axes are moved (for example if the user want to transform
-         * (NORTH,EAST) to (EAST,NORTH)), then ordinates at index {@code srcIndex} will have
+         * will be equal. If some axes are moved (for example if the user want to transform
+         * (NORTH,EAST) to (EAST,NORTH)), then coordinates at index {@code srcIndex} will have
          * to be moved at index {@code dstIndex}.
          */
         for (int dstIndex = 0; dstIndex < dstAxes.length; dstIndex++) {
@@ -397,7 +397,7 @@ public final class Matrices extends Static {
      *
      * <ul>
      *   <li>If some {@code srcAxes} directions can not be mapped to {@code dstAxes} directions, then the transform
-     *       will silently drops the ordinates associated to those extra source axis directions.</li>
+     *       will silently drops the coordinates associated to those extra source axis directions.</li>
      *   <li>If some {@code dstAxes} directions can not be mapped to {@code srcAxes} directions,
      *       then an exception will be thrown.</li>
      * </ul>
@@ -480,14 +480,14 @@ public final class Matrices extends Static {
      * }
      *
      * will return the following square matrix. The transform of a corner is given as an example.
-     * Note that the input ordinate values are swapped because of the (<i>North</i>, <i>West</i>) axis directions,
+     * Note that the input coordinate values are swapped because of the (<i>North</i>, <i>West</i>) axis directions,
      * and the lower-left corner of the destination envelope is the lower-<em>right</em> corner of the source envelope
      * because of the opposite axis direction.
      *
      * {@preformat math
      *   ┌     ┐   ┌               ┐   ┌     ┐
      *   │ -10 │   │ 0   -3.0  350 │   │ -40 │
-     *   │ -25 │ = │ 2.5  0     75 │ × │ 120 │       // 120 is the westernmost source ordinate: (x=20) + (width=100)
+     *   │ -25 │ = │ 2.5  0     75 │ × │ 120 │       // 120 is the westernmost source coordinate: (x=20) + (width=100)
      *   │   1 │   │ 0    0      1 │   │   1 │
      *   └     ┘   └               ┘   └     ┘
      * }
@@ -519,7 +519,7 @@ public final class Matrices extends Static {
     }
 
     /**
-     * Creates a matrix for a transform that keep only a subset of source ordinate values.
+     * Creates a matrix for a transform that keep only a subset of source coordinate values.
      * The matrix size will be ({@code selectedDimensions.length} + 1) × ({@code sourceDimensions} + 1).
      * The matrix will contain only zero elements, except for the following cells which will contain 1:
      *
@@ -529,9 +529,9 @@ public final class Matrices extends Static {
      * </ul>
      *
      * <div class="note"><b>Example:</b>
-     * given (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>) ordinate values, if one wants to keep
-     * (<var>y</var>,<var>x</var>,<var>t</var>) ordinates (note the <var>x</var> ↔ <var>y</var> swapping)
-     * and discard the <var>z</var> values, then the indices of source ordinates to select are 1 for <var>y</var>,
+     * given (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>) coordinate values, if one wants to keep
+     * (<var>y</var>,<var>x</var>,<var>t</var>) coordinates (note the <var>x</var> ↔ <var>y</var> swapping)
+     * and discard the <var>z</var> values, then the indices of source coordinates to select are 1 for <var>y</var>,
      * 0 for <var>x</var> and 3 for <var>t</var>. One can use the following method call:
      *
      * {@preformat java
@@ -556,7 +556,7 @@ public final class Matrices extends Static {
      * Other dimensions will work as expected.
      *
      * @param  sourceDimensions    the number of dimensions in source coordinates.
-     * @param  selectedDimensions  the 0-based indices of source ordinate values to keep.
+     * @param  selectedDimensions  the 0-based indices of source coordinate values to keep.
      *         The length of this array will be the number of dimensions in target coordinates.
      * @return an affine transform matrix keeping only the given source dimensions, and discarding all others.
      * @throws IllegalArgumentException if a value of {@code selectedDimensions} is lower than 0
@@ -577,7 +577,7 @@ public final class Matrices extends Static {
     }
 
     /**
-     * Creates a matrix which converts a subset of ordinates using the transform given by another matrix.
+     * Creates a matrix which converts a subset of coordinates using the transform given by another matrix.
      * For example giving (<var>latitude</var>, <var>longitude</var>, <var>height</var>) coordinates,
      * a pass through operation can convert the height values from feet to metres without affecting
      * the (<var>latitude</var>, <var>longitude</var>) values.
@@ -617,7 +617,7 @@ public final class Matrices extends Static {
      * }
      *
      * Then a call to {@code Matrices.createPassThrough(2, subMatrix, 1)} will return the following matrix,
-     * which can be used for converting the height (<var>z</var>) without affecting the other ordinate values
+     * which can be used for converting the height (<var>z</var>) without affecting the other coordinate values
      * (<var>x</var>,<var>y</var>,<var>t</var>):
      *
      * {@preformat math
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java
index 28ef560..ac044c8 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java
@@ -419,7 +419,7 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
      * <p>This method is useful when the matrix is a
      * {@linkplain org.opengis.referencing.operation.MathTransform#derivative transform derivative}.
      * In such matrix, each column is a vector representing the displacement in target space when an
-     * ordinate in the source space is increased by one. Invoking this method turns those vectors
+     * coordinate in the source space is increased by one. Invoking this method turns those vectors
      * into unitary vectors, which is useful for forming the basis of a new coordinate system.</p>
      *
      * @throws UnsupportedOperationException if this matrix is unmodifiable.
@@ -450,7 +450,7 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
     /**
      * Assuming that this matrix represents an affine transform, concatenates a scale and a translation on the
      * given dimension. Converting a point with the resulting matrix is equivalent to first convert the point
-     * with {@code ordinates[srcDim] = ordinates[srcDim] * scale + offset}, then apply the original matrix.
+     * with {@code coordinates[srcDim] = coordinates[srcDim] * scale + offset}, then apply the original matrix.
      *
      * <div class="section">Equivalence between this method and Java2D {@code AffineTransform} methods</div>
      * If this matrix was an instance of Java2D {@link AffineTransform}, then invoking this method would
@@ -471,9 +471,9 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
      *   </tr>
      * </table>
      *
-     * @param  srcDim  the dimension of the ordinate to rescale in the source coordinates.
-     * @param  scale   the amount by which to multiply the source ordinate value before to apply the transform, or {@code null} if none.
-     * @param  offset  the amount by which to translate the source ordinate value before to apply the transform, or {@code null} if none.
+     * @param  srcDim  the dimension of the coordinate to rescale in the source coordinates.
+     * @param  scale   the amount by which to multiply the source coordinate value before to apply the transform, or {@code null} if none.
+     * @param  offset  the amount by which to translate the source coordinate value before to apply the transform, or {@code null} if none.
      * @throws UnsupportedOperationException if this matrix is unmodifiable.
      *
      * @see AffineTransform#concatenate(AffineTransform)
@@ -504,11 +504,11 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
     /**
      * Assuming that this matrix represents an affine transform, pre-concatenates a scale and a translation on the
      * given dimension. Converting a point with the resulting matrix is equivalent to first convert the point with
-     * the original matrix, then convert the result with {@code ordinates[tgtDim] = ordinates[tgtDim] * scale + offset}.
+     * the original matrix, then convert the result with {@code coordinates[tgtDim] = coordinates[tgtDim] * scale + offset}.
      *
-     * @param  tgtDim  the dimension of the ordinate to rescale in the target coordinates.
-     * @param  scale   the amount by which to multiply the target ordinate value after this transform, or {@code null} if none.
-     * @param  offset  the amount by which to translate the target ordinate value after this transform, or {@code null} if none.
+     * @param  tgtDim  the dimension of the coordinate to rescale in the target coordinates.
+     * @param  scale   the amount by which to multiply the target coordinate value after this transform, or {@code null} if none.
+     * @param  offset  the amount by which to translate the target coordinate value after this transform, or {@code null} if none.
      * @throws UnsupportedOperationException if this matrix is unmodifiable.
      *
      * @see AffineTransform#preConcatenate(AffineTransform)
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java
index f2cafbb..8def848 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java
@@ -127,7 +127,7 @@ final class NonSquareMatrix extends GeneralMatrix {
      * If this matrix has more columns than rows, then this method can invert that matrix if and only if
      * some columns contain only 0 elements. In such case, the dimensions corresponding to those columns are
      * considered independent of all other dimensions. This happen typically with the dimension of <var>z</var>
-     * and <var>t</var> ordinate values.</p>
+     * and <var>t</var> coordinate values.</p>
      *
      * <p><b>Example:</b> in a conversion from (x₁,y₁,z,t) to (x₂,y₂), if the (x,y) dimensions are independent
      * of z and t dimensions, then we do not need those (z,t) dimensions for calculating the inverse of (x₁,y₁)
@@ -159,7 +159,7 @@ final class NonSquareMatrix extends GeneralMatrix {
      * <p>Conversely, if the matrix has more rows than columns (in a system of linear equations, the system would
      * be <cite>overdetermined</cite>), then we omit the rows containing only zero or NaN values. After the matrix
      * inversion, we insert columns having only zero values for the dimensions associated to those rows.
-     * Semantically, the inverse matrix is a (x₁,y₁,z,t) → (x₂,y₂) transform that just discards the ordinate values
+     * Semantically, the inverse matrix is a (x₁,y₁,z,t) → (x₂,y₂) transform that just discards the coordinate values
      * at the dimensions corresponding to those rows.</p>
      */
     @Override
@@ -172,8 +172,8 @@ final class NonSquareMatrix extends GeneralMatrix {
     }
 
     /**
-     * Inverses a matrix for a transform where target points have fewer ordinates than source points.
-     * If a column contains only zero values, then this means that the ordinate at the corresponding
+     * Inverses a matrix for a transform where target points have fewer coordinates than source points.
+     * If a column contains only zero values, then this means that the coordinate at the corresponding
      * column is simply deleted. We can omit that column. We check the last columns before the first
      * columns on the assumption that last dimensions are more likely to be independent dimensions
      * like time.
@@ -212,13 +212,13 @@ next:   do {
         }
         squareMatrix = (GeneralMatrix) Solver.inverse(squareMatrix, false);
         /*
-         * Create a new matrix with new rows added for the omitted ordinates.
+         * Create a new matrix with new rows added for the omitted coordinates.
          * From this point, the meaning of 'numCol' and 'numRow' are interchanged.
          */
         final NonSquareMatrix inverse = new NonSquareMatrix(numCol, numRow, false, 2);
         for (oi=0, j=0, i=0; i<numCol; i++) {
             if (oi != omitted.length && i == omitted[oi]) {
-                inverse.setElement(i, numRow-1, Double.NaN);  // Translation term to NaN, remaining to 0.
+                inverse.setElement(i, numRow-1, Double.NaN);        // Translation term to NaN, remaining to 0.
                 oi++;
             } else {
                 copyRow(squareMatrix, j++, inverse, i);
@@ -228,8 +228,8 @@ next:   do {
     }
 
     /**
-     * Inverses a matrix for a transform where target points has more ordinates than source points.
-     * In other words, the target matrices will be a transform that discard some ordinate values.
+     * Inverses a matrix for a transform where target points has more coordinates than source points.
+     * In other words, the target matrices will be a transform that discard some coordinate values.
      * We will discard the ones for which the row contains only 0 or NaN elements.
      *
      * <p>In the special case where the last row is of the form [0 0 … 0 1] as in affine transforms,
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
index 3b19b9c..917ea42 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
@@ -153,7 +153,7 @@ final class Solver implements Matrix {                          // Not Cloneable
      * Implementation of {@code solve} and {@code inverse} methods, with filtering of NaN values.
      * This method searches for NaN values before to attempt solving or inverting the matrix.
      * If some NaN values are found but the matrix is written in such a way that each NaN value
-     * is used for exactly one ordinate value (i.e. a matrix row is used for a one-dimensional
+     * is used for exactly one coordinate value (i.e. a matrix row is used for a one-dimensional
      * conversion which is independent of all other dimensions), then we will edit the matrix in
      * such a way that this NaN value does not prevent the inverse matrix to be computed.
      *
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
index 1b6974e..81788f4 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
@@ -657,7 +657,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
      * transform derivative if requested.
      *
      * <div class="section">Normalization</div>
-     * The input ordinates are (<var>λ</var>,<var>φ</var>) (the variable names for <var>longitude</var> and
+     * The input coordinates are (<var>λ</var>,<var>φ</var>) (the variable names for <var>longitude</var> and
      * <var>latitude</var> respectively) angles in radians, eventually pre-multiplied by projection-specific factors.
      * Input coordinate shall have the <cite>central meridian</cite> removed from the longitude by the caller
      * before this method is invoked. After this method is invoked, the caller will need to multiply the output
@@ -687,7 +687,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
      *                   angles in <strong>radians</strong>.
      * @param  srcOff    the offset of the single coordinate to be converted in the source array.
      * @param  dstPts    the array into which the converted coordinate is returned (may be the same than {@code srcPts}).
-     *                   Ordinates will be expressed in a dimensionless unit, as a linear distance on a unit sphere or ellipse.
+     *                   Coordinates will be expressed in a dimensionless unit, as a linear distance on a unit sphere or ellipse.
      * @param  dstOff    the offset of the location of the converted coordinate that is stored in the destination array.
      * @param  derivate  {@code true} for computing the derivative, or {@code false} if not needed.
      * @return the matrix of the projection derivative at the given source position,
@@ -700,7 +700,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
 
     /**
      * Inverse converts the single coordinate in {@code srcPts} at the given offset and stores the result in
-     * {@code ptDst} at the given offset. The output ordinates are (<var>longitude</var>, <var>latitude</var>)
+     * {@code ptDst} at the given offset. The output coordinates are (<var>longitude</var>, <var>latitude</var>)
      * angles in radians, usually (but not necessarily) in the range [-π … π] and [-π/2 … π/2] respectively.
      *
      * <div class="section">Normalization</div>
@@ -717,7 +717,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
      * @param  srcPts  the array containing the source point coordinate, as linear distance on a unit sphere or ellipse.
      * @param  srcOff  the offset of the point to be converted in the source array.
      * @param  dstPts  the array into which the converted point coordinate is returned (may be the same than {@code srcPts}).
-     *                 Ordinates will be (<var>longitude</var>, <var>latitude</var>) angles in <strong>radians</strong>.
+     *                 Coordinates will be (<var>longitude</var>, <var>latitude</var>) angles in <strong>radians</strong>.
      * @param  dstOff  the offset of the location of the converted point that is stored in the destination array.
      * @throws ProjectionException if the point can not be converted.
      */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java
index cc25be2..9f29dc5 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java
@@ -89,7 +89,7 @@
  * use grads instead of decimal degrees, and often the base geographic coordinate reference system is
  * (<var>latitude</var>, <var>longitude</var>) instead of (<var>longitude</var>, <var>latitude</var>).
  * This means that the cartographic projected transform is often used as a single step in a series of transforms,
- * where the other steps change units and swap ordinates.
+ * where the other steps change units and swap coordinates.
  * </blockquote>
  *
  * The Apache SIS implementation extends this rule to axis directions as well, i.e. (<var>x</var>, <var>y</var>) coordinates
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
index 9d857db..7099c5e 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
@@ -99,15 +99,15 @@ public abstract class AbstractMathTransform extends FormattableObject
 
     /**
      * Maximum amount of {@link TransformException} to catch while transforming a block of
-     * {@value #MAXIMUM_BUFFER_SIZE} ordinate values in an array. The default implementation of
+     * {@value #MAXIMUM_BUFFER_SIZE} coordinate values in an array. The default implementation of
      * {@code transform} methods set un-transformable coordinates to {@linkplain Double#NaN NaN}
      * before to let the exception propagate. However if more then {@value} exceptions occur in
-     * a block of {@value #MAXIMUM_BUFFER_SIZE} <em>ordinates</em> (not coordinates), then we
-     * will give up. We put a limit in order to avoid slowing down the application too much if
-     * a whole array is not transformable.
+     * a block of {@value #MAXIMUM_BUFFER_SIZE} <em>coordinates</em> (not coordinate tuples),
+     * then we will give up. We put a limit in order to avoid slowing down the application
+     * too much if a whole array is not transformable.
      *
      * <p>Note that in case of failure, the first {@code TransformException} is still propagated;
-     * we do not "eat" it. We just set the ordinates to {@code NaN} before to let the propagation
+     * we do not "eat" it. We just set the coordinates to {@code NaN} before to let the propagation
      * happen. If no exception handling should be performed at all, then {@code MAXIMUM_FAILURES}
      * can be set to 0.</p>
      *
@@ -287,19 +287,19 @@ public abstract class AbstractMathTransform extends FormattableObject
         } else {
             /*
              * Destination not set. We are going to create the destination here. Since we know that the
-             * destination will be the SIS implementation, write directly into the 'ordinates' array.
+             * destination will be the SIS implementation, write directly into the `coordinates` array.
              */
             final GeneralDirectPosition destination = new GeneralDirectPosition(dimTarget);
             final double[] source;
             if (dimSource <= dimTarget) {
-                source = destination.ordinates;
+                source = destination.coordinates;
                 for (int i=0; i<dimSource; i++) {
                     source[i] = ptSrc.getOrdinate(i);
                 }
             } else {
                 source = ptSrc.getCoordinate();
             }
-            transform(source, 0, destination.ordinates, 0, false);
+            transform(source, 0, destination.coordinates, 0, false);
             ptDst = destination;
         }
         return ptDst;
@@ -313,8 +313,8 @@ public abstract class AbstractMathTransform extends FormattableObject
      * {@preformat java
      *     Matrix derivative = null;
      *     if (derivate) {
-     *         double[] ordinates = Arrays.copyOfRange(srcPts, srcOff, srcOff + getSourceDimensions());
-     *         derivative = this.derivative(new GeneralDirectPosition(ordinates));
+     *         double[] coordinates = Arrays.copyOfRange(srcPts, srcOff, srcOff + getSourceDimensions());
+     *         derivative = this.derivative(new GeneralDirectPosition(coordinates));
      *     }
      *     this.transform(srcPts, srcOff, dstPts, dstOff, 1);                   // May overwrite srcPts.
      *     return derivative;
@@ -335,7 +335,7 @@ public abstract class AbstractMathTransform extends FormattableObject
      *
      * <div class="section">Note for implementors</div>
      * The source and destination may overlap. Consequently, implementors must read all source
-     * ordinate values before to start writing the transformed ordinates in the destination array.
+     * coordinate values before to start writing the transformed coordinates in the destination array.
      *
      * @param  srcPts    the array containing the source coordinate (can not be {@code null}).
      * @param  srcOff    the offset to the point to be transformed in the source array.
@@ -359,7 +359,7 @@ public abstract class AbstractMathTransform extends FormattableObject
      * Transforms a list of coordinate points. This method is provided for efficiently transforming many points.
      * The supplied array of coordinate values will contain packed coordinate values.
      *
-     * <div class="note"><b>Example:</b> if the source dimension is 3, then the ordinates will be packed in this order:
+     * <div class="note"><b>Example:</b> if the source dimension is 3, then the coordinates will be packed in this order:
      * (<var>x₀</var>,<var>y₀</var>,<var>z₀</var>,
      *  <var>x₁</var>,<var>y₁</var>,<var>z₁</var> …).
      * </div>
@@ -422,11 +422,11 @@ public abstract class AbstractMathTransform extends FormattableObject
         }
         /*
          * Now apply the coordinate transformation, invoking the user-overrideable method
-         * for each individual point. In case of failure, we will set the ordinates to NaN
+         * for each individual point. In case of failure, we will set the coordinates to NaN
          * and continue with other points, up to some maximal amount of failures.
          */
         TransformException failure = null;
-        int failureCount = 0;                           // Count ordinates, not coordinates.
+        int failureCount = 0;                           // Count coordinates, not coordinate tuples.
         int blockStart   = 0;
         do {
             try {
@@ -442,7 +442,7 @@ public abstract class AbstractMathTransform extends FormattableObject
                     throw failure;
                 }
                 /*
-                 * Otherwise set the ordinate values to NaN and count the number of exceptions,
+                 * Otherwise set the coordinate values to NaN and count the number of exceptions,
                  * so we know when to give up if there is too much of them. The first exception
                  * will be propagated at the end of this method.
                  */
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java
index 0fa954c..320b400 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java
@@ -102,11 +102,11 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
                             final double[] dstPts, final int dstOff,
                             final boolean derivate) throws TransformException
     {
-        final double ordinate = srcPts[srcOff];
+        final double coordinate = srcPts[srcOff];
         if (dstPts != null) {
-            dstPts[dstOff] = transform(ordinate);
+            dstPts[dstOff] = transform(coordinate);
         }
-        return derivate ? new Matrix1(derivative(ordinate)) : null;
+        return derivate ? new Matrix1(derivative(coordinate)) : null;
     }
 
     /**
@@ -131,14 +131,14 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
      */
     @Override
     public Matrix derivative(final DirectPosition point) throws TransformException {
-        final double ordinate;
+        final double coordinate;
         if (point == null) {
-            ordinate = Double.NaN;
+            coordinate = Double.NaN;
         } else {
             ensureDimensionMatches("point", 1, point);
-            ordinate = point.getOrdinate(0);
+            coordinate = point.getOrdinate(0);
         }
-        return new Matrix1(derivative(ordinate));
+        return new Matrix1(derivative(coordinate));
     }
 
     /**
@@ -193,11 +193,11 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
                                 final double[] dstPts, final int dstOff,
                                 final boolean derivate) throws TransformException
         {
-            final double ordinate = srcPts[srcOff];
+            final double coordinate = srcPts[srcOff];
             if (dstPts != null) {
-                dstPts[dstOff] = transform(ordinate);
+                dstPts[dstOff] = transform(coordinate);
             }
-            return derivate ? new Matrix1(derivative(ordinate)) : null;
+            return derivate ? new Matrix1(derivative(coordinate)) : null;
         }
 
         /**
@@ -211,14 +211,14 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
          */
         @Override
         public Matrix derivative(final DirectPosition point) throws TransformException {
-            final double ordinate;
+            final double coordinate;
             if (point == null) {
-                ordinate = Double.NaN;
+                coordinate = Double.NaN;
             } else {
                 ensureDimensionMatches("point", 1, point);
-                ordinate = point.getOrdinate(0);
+                coordinate = point.getOrdinate(0);
             }
-            return new Matrix1(derivative(ordinate));
+            return new Matrix1(derivative(coordinate));
         }
     }
 }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java
index 99e9d3c..b417614 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java
@@ -430,7 +430,7 @@ public class ContextualParameters extends Parameters implements Serializable {
     }
 
     /**
-     * Prepends a normalization step converting input ordinates in the two first dimensions from degrees to radians.
+     * Prepends a normalization step converting input coordinates in the two first dimensions from degrees to radians.
      * The normalization can optionally subtract the given λ₀ value (in degrees) from the longitude.
      *
      * <p>Invoking this method is equivalent to {@linkplain java.awt.geom.AffineTransform#concatenate concatenating}
@@ -463,7 +463,7 @@ public class ContextualParameters extends Parameters implements Serializable {
     }
 
     /**
-     * Appends a denormalization step after the non-linear kernel, which will convert input ordinates
+     * Appends a denormalization step after the non-linear kernel, which will convert input coordinates
      * in the two first dimensions from radians to degrees. After this conversion, the denormalization
      * can optionally add the given λ₀ value (in degrees) to the longitude.
      *
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java
index 4a65c3b..edf2ee7 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java
@@ -25,12 +25,12 @@ import org.apache.sis.referencing.operation.matrix.Matrices;
 
 
 /**
- * A transform which copy the ordinates in the source array to different locations in the target array.
+ * A transform which copy the coordinates in the source array to different locations in the target array.
  * This is a special case of {@link ProjectiveTransform} where the matrix coefficients are zero everywhere,
  * except one value by row which is set to 1 and is not the translation term. Those transforms are used for
  * swapping axis order, or selecting the dimension to retain when converting from a large dimension to a smaller one.
  * This transform has the particularity to involve no floating point operation - just copy of values with no change -
- * and consequently works well with NaN ordinate values.
+ * and consequently works well with NaN coordinate values.
  *
  * <p>We do not provide a subclass for the 2D case because our policy is to use
  * an {@link java.awt.geom.AffineTransform} for every 2D affine conversions.</p>
@@ -53,7 +53,7 @@ final class CopyTransform extends AbstractLinearTransform {
     private final int srcDim;
 
     /**
-     * The indices of ordinates to copy in the source array.
+     * The indices of coordinates to copy in the source array.
      * The length of this array is the target dimension.
      */
     private final int[] indices;
@@ -63,7 +63,7 @@ final class CopyTransform extends AbstractLinearTransform {
      *
      * @param srcDim   the dimension of source coordinates.
      *                 Must be greater than the highest value in {@code indices}.
-     * @param indices  the indices of ordinates to copy in the source array.
+     * @param indices  the indices of coordinates to copy in the source array.
      *                 The length of this array is the target dimension.
      */
     CopyTransform(final int srcDim, final int[] indices) {
@@ -103,7 +103,7 @@ final class CopyTransform extends AbstractLinearTransform {
                 }
             }
             if (!found) {
-                // Target ordinate unconditionally set to 0 (not a copy).
+                // Target coordinate unconditionally set to 0 (not a copy).
                 return null;
             }
         }
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
index 5bdb172..f5337df 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
@@ -966,7 +966,7 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
      *       the source or target CRS, if those parameters are not explicitly given and if they are relevant
      *       for the coordinate operation method.</li>
      *   <li>{@linkplain #createConcatenatedTransform Concatenating} the parameterized transform
-     *       with any other transforms required for performing units changes and ordinates swapping.</li>
+     *       with any other transforms required for performing units changes and coordinates swapping.</li>
      * </ol>
      *
      * The complete group of parameters, including {@code "semi_major"}, {@code "semi_minor"} or other calculated values,
@@ -1078,7 +1078,7 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
      * Given a transform between normalized spaces,
      * creates a transform taking in account axis directions, units of measurement and longitude rotation.
      * This method {@linkplain #createConcatenatedTransform concatenates} the given parameterized transform
-     * with any other transform required for performing units changes and ordinates swapping.
+     * with any other transform required for performing units changes and coordinates swapping.
      *
      * <p>The given {@code parameterized} transform shall expect
      * {@linkplain org.apache.sis.referencing.cs.AxesConvention#NORMALIZED normalized} input coordinates and
@@ -1263,7 +1263,7 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
      * Creates an affine transform from a matrix. If the transform input dimension is {@code M},
      * and output dimension is {@code N}, then the matrix will have size {@code [N+1][M+1]}. The
      * +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation. The
-     * {@code [M][j]} element of the matrix will be the j'th ordinate of the moved origin. The
+     * {@code [M][j]} element of the matrix will be the j'th coordinate of the moved origin. The
      * {@code [i][N]} element of the matrix will be 0 for <var>i</var> less than {@code M}, and 1
      * for <var>i</var> equals {@code M}.
      *
@@ -1316,8 +1316,8 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
     }
 
     /**
-     * Creates a transform which passes through a subset of ordinates to another transform.
-     * This allows transforms to operate on a subset of ordinates.
+     * Creates a transform which passes through a subset of coordinates to another transform.
+     * This allows transforms to operate on a subset of coordinates.
      *
      * <div class="note"><b>Example:</b>
      * Giving (<var>latitude</var>, <var>longitude</var>, <var>height</var>) coordinates,
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java
index 170bc57..0b3d4fe 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java
@@ -166,7 +166,7 @@ public class InterpolatedGeocentricTransform extends DatumShiftTransform {
 
     /**
      * Creates a transform from the specified parameters.
-     * This {@code InterpolatedGeocentricTransform} class expects ordinate values in the following order and units:
+     * This {@code InterpolatedGeocentricTransform} class expects coordinate values in the following order and units:
      * <ol>
      *   <li>longitudes in <strong>radians</strong> relative to the prime meridian (usually Greenwich),</li>
      *   <li>latitudes in <strong>radians</strong>,</li>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java
index d731805..8ef89da 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java
@@ -110,7 +110,7 @@ public class InterpolatedMolodenskyTransform extends MolodenskyFormula {
 
     /**
      * Creates a transform from the specified parameters.
-     * This {@code InterpolatedMolodenskyTransform} class expects ordinate values in the following order and units:
+     * This {@code InterpolatedMolodenskyTransform} class expects coordinate values in the following order and units:
      * <ol>
      *   <li>longitudes in <strong>radians</strong> relative to the prime meridian (usually Greenwich),</li>
      *   <li>latitudes in <strong>radians</strong>,</li>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java
index 586a1b4..31768c0 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java
@@ -96,7 +96,7 @@ public enum IterationStrategy {
 
     /**
      * Copy the points to transform in a temporary array before to apply the transform.
-     * The temporary array will be used for fetching the source ordinates.
+     * The temporary array will be used for fetching the source coordinates.
      *
      * <p>This algorithm can be used as a fallback for any unknown enumeration.</p>
      */
@@ -132,7 +132,7 @@ public enum IterationStrategy {
      *
      * <ul>
      *   <li>Source and target array are the same.</li>
-     *   <li>For each coordinate to be transformed, all ordinate values are read before the
+     *   <li>For each coordinate to be transformed, all coordinate values are read before the
      *       transformation process starts. For example if a transform goes from geographic
      *       to projected CRS, the (<var>longitude</var>, <var>latitude</var>, <var>height</var>)
      *       tuple must be completely read before to start writing the
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java
index dc40bad..deb3c93 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java
@@ -88,7 +88,7 @@ public interface LinearTransform extends MathTransform {
     /**
      * Returns the coefficients of this linear transform as a matrix.
      * Converting a coordinate with this {@code MathTransform} is equivalent to multiplying the
-     * returned matrix by a vector containing the ordinate values with an additional 1 in the last row.
+     * returned matrix by a vector containing the coordinate values with an additional 1 in the last row.
      * See {@link LinearTransform} class Javadoc for more details.
      *
      * @return the coefficients of this linear transform as a matrix.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java
index 8d3d046..04895bf 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java
@@ -179,7 +179,7 @@ public final class MathTransforms extends Static {
      * <p>If the transform input dimension is {@code M}, and output dimension is {@code N},
      * then the given matrix shall have size {@code [N+1][M+1]}.
      * The +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation.
-     * The {@code [M][j]} element of the matrix will be the <var>j</var>'th ordinate of the moved origin.</p>
+     * The {@code [M][j]} element of the matrix will be the <var>j</var>'th coordinate of the moved origin.</p>
      *
      * @param  matrix  the matrix used to define the linear transform.
      * @return the linear (usually affine) transform.
@@ -361,7 +361,7 @@ public final class MathTransforms extends Static {
     }
 
     /**
-     * Puts together a list of independent math transforms, each of them operating on a subset of ordinate values.
+     * Puts together a list of independent math transforms, each of them operating on a subset of coordinate values.
      * This method is often used for defining 4-dimensional (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>)
      * transform as an aggregation of 3 simpler transforms operating on (<var>x</var>,<var>y</var>), (<var>z</var>)
      * and (<var>t</var>) values respectively.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
index bb7a1a5..657cfa5 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
@@ -53,7 +53,7 @@ import static java.lang.Math.*;
  *       height (typically non-zero even if the input height was zero) is lost.</li>
  * </ul>
  *
- * The transform expect ordinate values if the following order:
+ * The transform expect coordinate values if the following order:
  * <ol>
  *   <li>longitudes (λ) relative to the prime meridian (usually Greenwich),</li>
  *   <li>latitudes (φ),</li>
@@ -110,7 +110,7 @@ public class MolodenskyTransform extends MolodenskyFormula {
 
     /**
      * Creates a Molodensky transform from the specified parameters.
-     * This {@code MolodenskyTransform} class expects ordinate values in the following order and units:
+     * This {@code MolodenskyTransform} class expects coordinate values in the following order and units:
      * <ol>
      *   <li>longitudes in <strong>radians</strong> relative to the prime meridian (usually Greenwich),</li>
      *   <li>latitudes in <strong>radians</strong>,</li>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
index d5f812d..c123458 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
@@ -513,7 +513,7 @@ public class PassThroughTransform extends AbstractMathTransform implements Seria
         ensureDimensionMatches("point", transDim + nSkipped, point);
         final GeneralDirectPosition subPoint = new GeneralDirectPosition(transDim);
         for (int i=0; i<transDim; i++) {
-            subPoint.ordinates[i] = point.getOrdinate(i + firstAffectedCoordinate);
+            subPoint.coordinates[i] = point.getOrdinate(i + firstAffectedCoordinate);
         }
         return expand(MatrixSIS.castOrCopy(subTransform.derivative(subPoint)),
                 firstAffectedCoordinate, numTrailingCoordinates, 0);
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java
index fe6fec3..a4efca3 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java
@@ -238,7 +238,7 @@ class ProjectiveTransform extends AbstractLinearTransform implements ExtendedPre
     @Override
     public final void transform(double[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
         final int srcDim, dstDim;
-        int srcInc = srcDim = numCol - 1; // The last ordinate will be assumed equal to 1.
+        int srcInc = srcDim = numCol - 1;               // The last coordinate will be assumed equal to 1.
         int dstInc = dstDim = numRow - 1;
         if (srcPts == dstPts) {
             switch (IterationStrategy.suggest(srcOff, srcDim, dstOff, dstDim, numPts)) {
@@ -269,7 +269,7 @@ class ProjectiveTransform extends AbstractLinearTransform implements ExtendedPre
                     if (e != 0) {
                         /*
                          * The purpose of the test for non-zero value is not performance (it is actually more likely
-                         * to slow down the calculation), but to get a valid sum even if some source ordinates are NaN.
+                         * to slow down the calculation), but to get a valid sum even if some source coordinates are NaN.
                          * This occurs when the ProjectiveTransform is used for excluding some dimensions, for example
                          * getting 2D points from 3D points. In such case, the fact that the excluded dimensions had
                          * NaN values should not force the retained dimensions to get NaN values.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java
index fc9bb4d..6a98aad 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java
@@ -27,7 +27,7 @@ import org.apache.sis.util.ArraysExt;
 
 
 /**
- * An affine transform that multiply the ordinate values by constant values, and optionally drop the last ordinates.
+ * An affine transform that multiply the coordinate values by constant values, and optionally drop the last coordinates.
  * This is an optimization of {@link ProjectiveTransform} for a common case.
  *
  * <div class="note"><b>Note:</b> we do not provide two-dimensional specialization because
@@ -48,7 +48,7 @@ final class ScaleTransform extends AbstractLinearTransform implements ExtendedPr
     private static final long serialVersionUID = 8527439133082104085L;
 
     /**
-     * Multiplication factors, to be applied in the same order than ordinate values.
+     * Multiplication factors, to be applied in the same order than coordinate values.
      * The length of this array is the number of target dimensions.
      */
     private final double[] factors;
@@ -60,7 +60,7 @@ final class ScaleTransform extends AbstractLinearTransform implements ExtendedPr
     private final double[] errors;
 
     /**
-     * Number of ordinate values to drop after the values that we multiplied.
+     * Number of coordinate values to drop after the values that we multiplied.
      * Values to drop happen for example in Geographic 3D to 2D conversions.
      */
     private final int numDroppedDimensions;
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java
index 8ea54b0..2071d61 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java
@@ -26,7 +26,7 @@ import org.apache.sis.util.ArraysExt;
 
 
 /**
- * An affine transform that translate the ordinate values by constant values.
+ * An affine transform that translate the coordinate values by constant values.
  *
  * <div class="note"><b>Note:</b> we do not provide two-dimensional specialization because
  * {@link org.apache.sis.internal.referencing.j2d.AffineTransform2D} should be used in such case.</div>
@@ -46,7 +46,7 @@ final class TranslationTransform extends AbstractLinearTransform implements Exte
     private static final long serialVersionUID = 7382503993222285134L;
 
     /**
-     * Translation terms, to be applied in the same order than ordinate values.
+     * Translation terms, to be applied in the same order than coordinate values.
      * The length of this array is the number of target dimensions.
      */
     private final double[] offsets;
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
index e7487aa..b6a7700 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
@@ -107,13 +107,13 @@ public final strictfp class AbstractEnvelopeTest extends TestCase {
         switch (type) {
             case SUBENVELOPE: {
                 // Asserts that other dimensions in the original envelope has not been modified.
-                final double[] ordinates = ((SubEnvelope) envelope).ordinates;
-                assertEquals(2, ordinates[0], STRICT);
-                assertEquals(3, ordinates[5], STRICT);
-                assertEquals(4, ordinates[3], STRICT);
-                assertEquals(6, ordinates[8], STRICT);
-                assertEquals(8, ordinates[4], STRICT);
-                assertEquals(9, ordinates[9], STRICT);
+                final double[] coordinates = ((SubEnvelope) envelope).coordinates;
+                assertEquals(2, coordinates[0], STRICT);
+                assertEquals(3, coordinates[5], STRICT);
+                assertEquals(4, coordinates[3], STRICT);
+                assertEquals(6, coordinates[8], STRICT);
+                assertEquals(8, coordinates[4], STRICT);
+                assertEquals(9, coordinates[9], STRICT);
                 break;
             }
         }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java
index ce2a886..4f77c3e 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java
@@ -42,7 +42,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
     public void testIsEmpty() {
         ArrayEnvelope envelope = new ArrayEnvelope(new double[] {0, -356.683168});
         assertTrue(envelope.isEmpty());
-        envelope.ordinates[0] = -360;
+        envelope.coordinates[0] = -360;
         assertFalse(envelope.isEmpty());
     }
 
@@ -52,14 +52,14 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
     @Test
     public void testGetExtremums() {
         ArrayEnvelope envelope = new ArrayEnvelope(2);
-        envelope.ordinates[2] = -1728;
+        envelope.coordinates[2] = -1728;
         assertTrue(Double.isNaN(envelope.getMinimum(0)));
         assertTrue(Double.isNaN(envelope.getMaximum(0)));
         assertEquals(0, envelope.getMinimum(1), STRICT);
         assertEquals(0, envelope.getMaximum(1), STRICT);
 
         // Make the range valid and test again.
-        envelope.ordinates[0] = -1800;
+        envelope.coordinates[0] = -1800;
         assertEquals(-1800, envelope.getMinimum(0), STRICT);
         assertEquals(-1728, envelope.getMaximum(0), STRICT);
     }
@@ -91,7 +91,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
         assertArrayEquals(new double[] {
             -5610.14928, -3642.5148, 1957.4432, -170.0175, -77.9698, Double.NEGATIVE_INFINITY,
             -5610.14920, -3642.5140, 1957.4440, -170.0170, -77.9690, Double.NEGATIVE_INFINITY
-        }, envelope.ordinates, STRICT);
+        }, envelope.coordinates, STRICT);
     }
 
     /**
@@ -99,7 +99,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
      */
     @Test(expected = IllegalArgumentException.class)
     public void testCreatesFromInvalidWKT() {
-        assertNotNull(new ArrayEnvelope("BBOX[\"invalid\"]").ordinates);
+        assertNotNull(new ArrayEnvelope("BBOX[\"invalid\"]").coordinates);
     }
 
     /**
@@ -125,7 +125,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
         assertTrue (env1.equals(env1));
         assertTrue (env2.equals(env2));
 
-        env2.ordinates[0] = 1;
+        env2.coordinates[0] = 1;
         assertTrue(env1.equals(env2));
         assertTrue(env2.equals(env1));
     }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java
index 7a30075..28ae885 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java
@@ -50,7 +50,7 @@ import static org.junit.Assert.*;
 public final strictfp class CoordinateFormatTest extends TestCase {
     /**
      * Tests formatting a coordinate in unknown CRS.
-     * The ordinate values are expected to be formatted as ordinary numbers.
+     * The coordinate values are expected to be formatted as ordinary numbers.
      */
     @Test
     public void testFormatUnknownCRS() {
@@ -73,7 +73,7 @@ public final strictfp class CoordinateFormatTest extends TestCase {
 
     /**
      * Tests parsing a coordinate in unknown CRS.
-     * The ordinate values are formatted as ordinary numbers.
+     * The coordinate values are formatted as ordinary numbers.
      *
      * @throws ParseException if the parsing failed.
      */
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java
index cb00f38..a77d93b 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java
@@ -83,8 +83,8 @@ public final strictfp class DirectPosition1DTest extends TestCase {
     public void testClone() {
         final DirectPosition1D p1 = new DirectPosition1D(20);
         final DirectPosition1D p2 = p1.clone();
-        assertEquals("Expected the same CRS and ordinates.", p1, p2);
-        assertEquals("Expected the same ordinates.", 20.0, p2.ordinate, 0.0);
+        assertEquals("Expected the same CRS and coordinates.", p1, p2);
+        assertEquals("Expected the same coordinates.", 20.0, p2.coordinate, 0.0);
         validate(p2);
     }
 
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java
index d387171..b1faab8 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java
@@ -83,9 +83,9 @@ public final strictfp class DirectPosition2DTest extends TestCase {
     public void testClone() {
         final DirectPosition2D p1 = new DirectPosition2D(10, 30);
         final DirectPosition2D p2 = p1.clone();
-        assertEquals("Expected the same CRS and ordinates.", p1, p2);
-        assertEquals("Expected the same ordinates.", 10.0, p2.x, 0.0);
-        assertEquals("Expected the same ordinates.", 30.0, p2.y, 0.0);
+        assertEquals("Expected the same CRS and coordinates.", p1, p2);
+        assertEquals("Expected the same coordinates.", 10.0, p2.x, 0.0);
+        assertEquals("Expected the same coordinates.", 30.0, p2.y, 0.0);
         validate(p2);
     }
 
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java
index a58cd29..e0bf6b5 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java
@@ -146,7 +146,7 @@ public final strictfp class EnvelopesTest extends TransformTestCase<GeneralEnvel
 
     /**
      * Tests the transformation of an envelope from a 4D CRS to a 2D CRS
-     * where the ordinates in one dimension are NaN.
+     * where the coordinates in one dimension are NaN.
      *
      * @throws TransformException if an error occurred while transforming the envelope.
      *
@@ -170,7 +170,7 @@ public final strictfp class EnvelopesTest extends TransformTestCase<GeneralEnvel
         assertTrue ("isEmpty",  env.isEmpty());         // Opportunist test (not really the topic of this method).
         /*
          * If the referencing framework has selected the CopyTransform implementation
-         * as expected, then the envelope ordinates should not be NaN.
+         * as expected, then the envelope coordinates should not be NaN.
          */
         final Envelope env2D = Envelopes.transform(env, targetCRS);
         assertEquals(-170, env2D.getMinimum(0), 0);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java
index 91bdf4b..3f73317 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java
@@ -91,9 +91,9 @@ public final strictfp class GeneralDirectPositionTest extends TestCase {
     public void testClone() {
         final GeneralDirectPosition p1 = new GeneralDirectPosition(10, 20, 30);
         final GeneralDirectPosition p2 = p1.clone();
-        assertEquals ("Expected the same CRS and ordinates.", p1, p2);
-        assertTrue   ("Expected the same ordinates.", Arrays.equals(p1.ordinates, p2.ordinates));
-        assertNotSame("the ordinates array should have been cloned.", p1.ordinates, p2.ordinates);
+        assertEquals ("Expected the same CRS and coordinates.", p1, p2);
+        assertTrue   ("Expected the same coordinates.", Arrays.equals(p1.coordinates, p2.coordinates));
+        assertNotSame("The coordinates array should have been cloned.", p1.coordinates, p2.coordinates);
         validate(p2);
     }
 
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java
index ab42d3e..43b86db 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java
@@ -58,7 +58,7 @@ public strictfp class GeneralEnvelopeTest extends TestCase {
     boolean skipValidation;
 
     /**
-     * Creates a new geographic envelope for the given ordinate values.
+     * Creates a new geographic envelope for the given coordinate values.
      * This method is overridden by {@link SubEnvelopeTest}.
      */
     GeneralEnvelope create(final double xmin, final double ymin, final double xmax, final double ymax) {
@@ -81,17 +81,17 @@ public strictfp class GeneralEnvelopeTest extends TestCase {
 
     /**
      * Asserts that the given two-dimensional envelope is equals to the given rectangle.
-     * The {@code xLower} and {@code xUpper} arguments are the <var>x</var> ordinate values
+     * The {@code xLower} and {@code xUpper} arguments are the <var>x</var> coordinate values
      * for the lower and upper corners respectively. The actual {@code xmin} and {@code ymin}
      * values will be inferred from those corners.
      *
      * <p>This method assumes that only the <var>x</var> axis may be a wraparound axis.</p>
      *
      * @param  test    the actual envelope to verify.
-     * @param  xLower  the expected first   <var>x</var> ordinate value. May  be greater than {@code xUpper}.
-     * @param  xUpper  the expected last    <var>x</var> ordinate value. May  be less    than {@code xLower}.
-     * @param  ymin    the expected minimal <var>y</var> ordinate value. Must be less    than {@code ymax}.
-     * @param  ymax    the expected maximal <var>y</var> ordinate value. Must be greater than {@code ymax}.
+     * @param  xLower  the expected first   <var>x</var> coordinate value. May  be greater than {@code xUpper}.
+     * @param  xUpper  the expected last    <var>x</var> coordinate value. May  be less    than {@code xLower}.
+     * @param  ymin    the expected minimal <var>y</var> coordinate value. Must be less    than {@code ymax}.
+     * @param  ymax    the expected maximal <var>y</var> coordinate value. Must be greater than {@code ymax}.
      */
     private static void assertEnvelopeEquals(final Envelope test,
             final double xLower, final double ymin, final double xUpper, final double ymax)
@@ -736,7 +736,7 @@ public strictfp class GeneralEnvelopeTest extends TestCase {
         assertNotSame("Expected a new instance.",           e1, e2);
         assertEquals ("The two instances should be equal.", e1, e2);
         e1.setRange(0, -40, +61);
-        assertFalse("Ordinates array should have been cloned.", e1.equals(e2));
+        assertFalse("Coordinates array should have been cloned.", e1.equals(e2));
         e2.setRange(0, -40, +61);
         assertEquals(e1, e2);
     }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java
index 18f8bc7..d32f09b 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java
@@ -38,7 +38,7 @@ import static org.apache.sis.geometry.AbstractEnvelopeTest.WGS84;
 @DependsOn(GeneralEnvelopeTest.class)
 public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
     /**
-     * Creates a new sub-envelope envelope for the given ordinate values.
+     * Creates a new sub-envelope envelope for the given coordinate values.
      */
     @Override
     GeneralEnvelope create(final double xmin, final double ymin, final double xmax, final double ymax) {
@@ -62,13 +62,13 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
     @Override
     void verifyInvariants(final GeneralEnvelope envelope) {
         super.verifyInvariants(envelope);
-        final double[] ordinates = envelope.ordinates;
-        assertEquals(1, ordinates[0], STRICT);
-        assertEquals(4, ordinates[1], STRICT);
-        assertEquals(5, ordinates[4], STRICT);
-        assertEquals(2, ordinates[5], STRICT);
-        assertEquals(7, ordinates[6], STRICT);
-        assertEquals(9, ordinates[9], STRICT);
+        final double[] coordinates = envelope.coordinates;
+        assertEquals(1, coordinates[0], STRICT);
+        assertEquals(4, coordinates[1], STRICT);
+        assertEquals(5, coordinates[4], STRICT);
+        assertEquals(2, coordinates[5], STRICT);
+        assertEquals(7, coordinates[6], STRICT);
+        assertEquals(9, coordinates[9], STRICT);
     }
 
     /**
@@ -85,7 +85,7 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
     public void testSetToNaN() {
         final GeneralEnvelope e = create(-40, -20, +60, +30);
         e.setToNaN();
-        assertArrayEquals(new double[] {1, 4, NaN, NaN, 5, 2, 7, NaN, NaN, 9}, e.ordinates, STRICT);
+        assertArrayEquals(new double[] {1, 4, NaN, NaN, 5, 2, 7, NaN, NaN, 9}, e.coordinates, STRICT);
         validate(e);
     }
 
@@ -98,11 +98,11 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
         final GeneralEnvelope e1 = create(-40, -20, +60, +30);
         final GeneralEnvelope e2 = create(-40, -20, +60, +30);
         assertEquals(e1, e2);
-        e2.ordinates[0] = -1;
-        e2.ordinates[1] = -4;
-        e2.ordinates[9] = -9;
+        e2.coordinates[0] = -1;
+        e2.coordinates[1] = -4;
+        e2.coordinates[9] = -9;
         assertEquals(e1, e2);
-        e2.ordinates[2] = -41;
+        e2.coordinates[2] = -41;
         assertFalse(e1.equals(e2));
     }
 
@@ -114,8 +114,8 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
     public void testClone() {
         final GeneralEnvelope e1 = create(-40, -20, +60, +30);
         final GeneralEnvelope e2 = e1.clone();
-        assertArrayEquals(new double[] {1, 4, -40, -20, 5, 2, 7, +60, +30, 9}, e1.ordinates, STRICT);
-        assertArrayEquals(new double[] {      -40, -20,          +60, +30   }, e2.ordinates, STRICT);
+        assertArrayEquals(new double[] {1, 4, -40, -20, 5, 2, 7, +60, +30, 9}, e1.coordinates, STRICT);
+        assertArrayEquals(new double[] {      -40, -20,          +60, +30   }, e2.coordinates, STRICT);
         validate(e2);
     }
 }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java b/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java
index 4c9e57f..5f8e509 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java
@@ -128,7 +128,7 @@ public final strictfp class GeographicOffsetsTest extends TransformTestCase {
         /*
          * Now create the MathTransform. But at the difference of the above testVerticalOffset() method,
          * we supply information about axis directions. The operation parameter shall have the same sign
-         * than in the EPSG database (which is positive), and the source and target ordinates shall have
+         * than in the EPSG database (which is positive), and the source and target coordinates shall have
          * the same sign than in the EPSG example (positive too). However we do not test unit conversion
          * in this method (EPSG sample point uses feet units), only axis direction.
          */
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java
index 7f43445..0e82a40 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java
@@ -39,7 +39,7 @@ import org.apache.sis.measure.Units;
 public final strictfp class HardCodedAxes {
     /**
      * Axis for geodetic longitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#EAST East}
+     * Increasing coordinate values go {@linkplain AxisDirection#EAST East}
      * and units are {@linkplain Units#DEGREE degrees}.
      * The ISO 19111 name is <cite>"geodetic longitude"</cite> and the abbreviation is "λ" (lambda).
      *
@@ -55,7 +55,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for geodetic latitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#NORTH North}
+     * Increasing coordinate values go {@linkplain AxisDirection#NORTH North}
      * and units are {@linkplain Units#DEGREE degrees}.
      * The ISO 19111 name is <cite>"geodetic latitude"</cite> and the abbreviation is "φ" (phi).
      *
@@ -78,7 +78,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for longitudes in grad units.
      * The axis name is {@code "Longitude"} (the {@code "Geodetic"} prefix is omitted for testing purpose).
-     * Increasing ordinates values go {@linkplain AxisDirection#EAST East} and units are {@link Units#GRAD}.
+     * Increasing coordinate values go {@linkplain AxisDirection#EAST East} and units are {@link Units#GRAD}.
      * The abbreviation is "λ" (lambda). The unit symbol is "gon".
      *
      * @see #GEODETIC_LONGITUDE
@@ -90,7 +90,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for latitudes in grad units.
      * The axis name is {@code "Latitude"} (the {@code "Geodetic"} prefix is omitted for testing purpose).
-     * Increasing ordinates values go {@linkplain AxisDirection#NORTH North} and units are {@link Units#GRAD}.
+     * Increasing coordinate values go {@linkplain AxisDirection#NORTH North} and units are {@link Units#GRAD}.
      * The abbreviation is "φ" (phi). The unit symbol is "gon".
      *
      * @see #GEODETIC_LATITUDE
@@ -102,7 +102,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for height values above the ellipsoid in a
      * {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"ellipsoidal height"</cite> and the abbreviation is lower case <cite>"h"</cite>.
      *
      * <p>This axis is usually part of a {@link #GEODETIC_LONGITUDE}, {@link #GEODETIC_LATITUDE},
@@ -120,7 +120,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for height values above the ellipsoid in a
      * {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#CENTIMETRE centimetres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#CENTIMETRE centimetres}.
      *
      * @since 0.7
      */
@@ -129,7 +129,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for height values measured from gravity.
-     * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"gravity-related height"</cite> and the abbreviation is upper case <cite>"H"</cite>.
      *
      * @see #ALTITUDE
@@ -148,7 +148,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for altitude values.
-     * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
      * The abbreviation is lower case <cite>"h"</cite>.
      *
      * <p>This axis is usually part of a {@link #GEODETIC_LONGITUDE}, {@link #GEODETIC_LATITUDE},
@@ -164,7 +164,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for depth.
-     * Increasing ordinates values go {@linkplain AxisDirection#DOWN down} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#DOWN down} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"depth"</cite>.
      *
      * @see #ALTITUDE
@@ -178,7 +178,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for radius in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
      * using {@linkplain org.apache.sis.referencing.cs.DefaultSphericalCS spherical CS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"geocentric radius"</cite> and the abbreviation is lower-case <cite>"r"</cite>.
      *
      * <div class="note"><b>Note:</b>
@@ -202,7 +202,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for longitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
      * using {@linkplain org.apache.sis.referencing.cs.DefaultSphericalCS spherical CS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#EAST East}
+     * Increasing coordinate values go {@linkplain AxisDirection#EAST East}
      * and units are {@linkplain Units#DEGREE degrees}.
      * The ISO 19111 name is <cite>"spherical longitude"</cite> (also called <cite>"azimuthal angle"</cite>)
      * and the abbreviation is "θ" (theta).
@@ -226,7 +226,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for latitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
      * using {@linkplain org.apache.sis.referencing.cs.DefaultSphericalCS spherical CS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#NORTH North}
+     * Increasing coordinate values go {@linkplain AxisDirection#NORTH North}
      * and units are {@linkplain Units#DEGREE degrees}.
      * The ISO 19111 name is <cite>"spherical latitude"</cite> (also called <cite>"polar (zenith) angle"</cite>)
      * and the abbreviation is "Ω".
@@ -248,7 +248,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for <var>x</var> values in a {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
      * The abbreviation is lower case <cite>"x"</cite>.
      *
      * <p>This axis is usually part of a {@link #X}, {@link #Y}, {@link #Z} set.</p>
@@ -264,7 +264,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for <var>y</var> values in a {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
      * The abbreviation is lower case <cite>"y"</cite>.
      *
      * <p>This axis is usually part of a {@link #X}, {@link #Y}, {@link #Z} set.</p>
@@ -280,7 +280,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for <var>z</var> values in a {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
      * The abbreviation is lower case <cite>"z"</cite>.
      *
      * <p>This axis is usually part of a {@link #X}, {@link #Y}, {@link #Z} set.</p>
@@ -291,7 +291,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for <var>x</var> values in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
      * using {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
-     * Increasing ordinates values goes typically toward prime meridian, but the actual axis direction
+     * Increasing coordinate values goes typically toward prime meridian, but the actual axis direction
      * is {@link AxisDirection#GEOCENTRIC_X GEOCENTRIC_X}. The units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"Geocentric X"</cite> and the abbreviation is upper case <cite>"X"</cite>.
      *
@@ -306,7 +306,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for <var>y</var> values in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
      * using {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
-     * Increasing ordinates values goes typically toward East, but the actual axis direction is
+     * Increasing coordinate values goes typically toward East, but the actual axis direction is
      * {@link AxisDirection#GEOCENTRIC_Y GEOCENTRIC_Y}. The units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"Geocentric Y"</cite> and the abbreviation is upper case <cite>"Y"</cite>.
      *
@@ -321,7 +321,7 @@ public final strictfp class HardCodedAxes {
     /**
      * Axis for <var>z</var> values in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
      * using {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
-     * Increasing ordinates values goes typically toward North, but the actual axis direction is
+     * Increasing coordinate values goes typically toward North, but the actual axis direction is
      * {@link AxisDirection#GEOCENTRIC_Z GEOCENTRIC_Z}. The units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"Geocentric Z"</cite> and the abbreviation is upper case <cite>"Z"</cite>.
      *
@@ -335,7 +335,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for Easting values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"easting"</cite> and the abbreviation is upper case <cite>"E"</cite>.
      *
      * <p>This axis is usually part of a {@link #EASTING}, {@link #NORTHING} set.</p>
@@ -349,7 +349,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for Westing values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#WEST West} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#WEST West} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"westing"</cite> and the abbreviation is upper case <cite>"W"</cite>.
      *
      * @see #X
@@ -361,7 +361,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for Northing values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"northing"</cite> and the abbreviation is upper case <cite>"N"</cite>.
      *
      * <p>This axis is usually part of a {@link #EASTING}, {@link #NORTHING} set.</p>
@@ -375,7 +375,7 @@ public final strictfp class HardCodedAxes {
 
     /**
      * Axis for Southing values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
-     * Increasing ordinates values go {@linkplain AxisDirection#SOUTH South} and units are {@linkplain Units#METRE metres}.
+     * Increasing coordinate values go {@linkplain AxisDirection#SOUTH South} and units are {@linkplain Units#METRE metres}.
      * The ISO 19111 name is <cite>"southing"</cite> and the abbreviation is upper case <cite>"S"</cite>.
      *
      * @see #Y
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java
index 2da281d..995476d 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java
@@ -114,7 +114,7 @@ public final strictfp class TimeDependentBWPTest extends TestCase {
         compareWithExplicitCalculation(actual);
         /*
          * Now compare with the expected value given in the EPSG example. The 0.013 tolerance threshold
-         * is for the X ordinate and has been determined empirically in testEpsgCalculation().
+         * is for the X coordinate and has been determined empirically in testEpsgCalculation().
          */
         assertMatrixEquals("toGDA94",    target, actual, 0.013);
         assertMatrixEquals("toITRF2008", source, toITRF2008.multiply(target), 0.013);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java
index c928371..b381f62 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java
@@ -691,7 +691,7 @@ public final strictfp class CoordinateOperationFinderTest extends MathTransformT
 
     /**
      * Tests the conversion from a two-dimensional geographic CRS to a three-dimensional geographic CRS.
-     * Ordinate values of the vertical dimension should be set to zero.
+     * Coordinate values of the vertical dimension should be set to zero.
      *
      * @throws FactoryException if the operation can not be created.
      * @throws TransformException if an error occurred while converting the test points.
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java
index f3d2fd9..c011acf 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java
@@ -55,7 +55,7 @@ public final strictfp class HardCodedConversions {
 
     /**
      * A two-dimensional Mercator projection using the WGS84 datum.
-     * This CRS uses (<var>easting</var>, <var>northing</var>) ordinates in metres.
+     * This CRS uses (<var>easting</var>, <var>northing</var>) coordinates in metres.
      * The base CRS uses (<var>longitude</var>, <var>latitude</var>) axes
      * and the prime meridian is Greenwich.
      *
@@ -71,7 +71,7 @@ public final strictfp class HardCodedConversions {
 
     /**
      * A three-dimensional Mercator projection using the WGS84 datum.
-     * This CRS uses (<var>easting</var>, <var>northing</var>, <var>height</var>) ordinates in metres.
+     * This CRS uses (<var>easting</var>, <var>northing</var>, <var>height</var>) coordinates in metres.
      * The base CRS uses (<var>longitude</var>, <var>latitude</var>, <var>height</var>) axes
      * and the prime meridian is Greenwich.
      *
@@ -84,7 +84,7 @@ public final strictfp class HardCodedConversions {
 
     /**
      * A two- or three-dimensional Mercator projection using the given base CRS.
-     * This CRS uses (<var>easting</var>, <var>northing</var>) ordinates in metres.
+     * This CRS uses (<var>easting</var>, <var>northing</var>) coordinates in metres.
      *
      * @param  baseCRS  the two- or three-dimensional base CRS.
      * @return two- or three-dimensional Mercator projection.
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java
index 868ce37..02fe30c 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java
@@ -269,9 +269,9 @@ public final strictfp class LinearTransformBuilderTest extends TestCase {
         final Map<DirectPosition1D,DirectPosition1D> pos = new HashMap<>(numPts);
         for (int i=0; i<numPts; i++) {
             final DirectPosition1D src = new DirectPosition1D(rd.nextDouble() * 100 - 50);
-            final DirectPosition1D tgt = new DirectPosition1D(src.ordinate * scale + offset);
+            final DirectPosition1D tgt = new DirectPosition1D(src.coordinate * scale + offset);
             if (addErrors) {
-                tgt.ordinate += rd.nextDouble() * 10 - 5;
+                tgt.coordinate += rd.nextDouble() * 10 - 5;
             }
             assertNull(pos.put(src, tgt));
         }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java
index 13db25e..0c16aff 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java
@@ -273,7 +273,7 @@ public final strictfp class MatricesTest extends TestCase {
             0,    0,   0,   1
         }), matrix);
         /*
-         * Test adding a dimension with ordinate values set to zero.
+         * Test adding a dimension with coordinate values set to zero.
          */
         expanded.subEnvelope(0, 2).setEnvelope(dstEnvelope);
         matrix = Matrices.createTransform(srcEnvelope, expanded);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java
index 0392c23..f29d1fa 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java
@@ -95,8 +95,8 @@ public final strictfp class AlbersEqualAreaTest extends MapProjectionTestCase {
         /*
          * Verify consistency with random points.
          */
-        verifyInDomain(new double[] {-20, 20},          // Minimal input ordinate values
-                       new double[] {+20, 50},          // Maximal input ordinate values
+        verifyInDomain(new double[] {-20, 20},          // Minimal input coordinate values
+                       new double[] {+20, 50},          // Maximal input coordinate values
                        new int[]    {  5,  5},          // Number of points to test
                        TestUtilities.createRandomNumberGenerator());
     }
@@ -148,8 +148,8 @@ public final strictfp class AlbersEqualAreaTest extends MapProjectionTestCase {
         /*
          * Verify consistency with random points.
          */
-        verifyInDomain(new double[] {-20, 20},          // Minimal input ordinate values
-                       new double[] {+20, 50},          // Maximal input ordinate values
+        verifyInDomain(new double[] {-20, 20},          // Minimal input coordinate values
+                       new double[] {+20, 50},          // Maximal input coordinate values
                        new int[]    {  5,  5},          // Number of points to test
                        TestUtilities.createRandomNumberGenerator());
     }
@@ -249,8 +249,8 @@ public final strictfp class AlbersEqualAreaTest extends MapProjectionTestCase {
         toleranceModifier = ToleranceModifier.PROJECTION;
         final double delta = toRadians(100.0 / 60) / 1852;      // Approximately 100 metres.
         derivativeDeltas = new double[] {delta, delta};
-        verifyInDomain(new double[] {-40, 10},                  // Minimal input ordinate values
-                       new double[] {+40, 60},                  // Maximal input ordinate values
+        verifyInDomain(new double[] {-40, 10},                  // Minimal input coordinate values
+                       new double[] {+40, 60},                  // Maximal input coordinate values
                        new int[]    {  5,  5},                  // Number of points to test
                        TestUtilities.createRandomNumberGenerator());
     }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java
index 546305f..8aa9eb2 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java
@@ -223,7 +223,7 @@ public final strictfp class AbstractMathTransformTest extends TestCase {
                     }
                 }
                 /*
-                 * Inspects each transformed coordinates. Either all ordinates are NaN, or either
+                 * Inspects each transformed coordinates. Either all coordinates are NaN, or either
                  * none of them are. Verifies with RandomFailureTransform if the NaN state is the
                  * expected one.
                  */
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java
index 3e6db5f..076aff8 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java
@@ -68,23 +68,23 @@ public strictfp class CoordinateDomain {
                 throw new IllegalArgumentException();
             }
             final double axis = GeodeticDatumMock.SPHERE.getEllipsoid().getSemiMajorAxis();
-            final double[] ordinates = GEOGRAPHIC.generateRandomInput(random, dimension, numPts);
-            for (int i=0; i<ordinates.length;) {
-                final double phi    = toRadians(ordinates[i  ]);
-                final double theta  = toRadians(ordinates[i+1]);
-                final double radius = axis  +   ordinates[i+2];
+            final double[] coordinates = GEOGRAPHIC.generateRandomInput(random, dimension, numPts);
+            for (int i=0; i<coordinates.length;) {
+                final double phi    = toRadians(coordinates[i  ]);
+                final double theta  = toRadians(coordinates[i+1]);
+                final double radius = axis  +   coordinates[i+2];
                 final double radXY  = radius * cos(theta);
-                ordinates[i++] = radXY  * cos(phi);
-                ordinates[i++] = radXY  * sin(phi);
-                ordinates[i++] = radius * sin(theta);
+                coordinates[i++] = radXY  * cos(phi);
+                coordinates[i++] = radXY  * sin(phi);
+                coordinates[i++] = radius * sin(theta);
             }
-            return ordinates;
+            return coordinates;
         }
     };
 
     /**
      * Geographic input coordinates with angles in decimal degrees.
-     * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+     * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC = new CoordinateDomain(
             Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -93,7 +93,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates avoiding poles and anti-meridian.
-     * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+     * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_SAFE = new CoordinateDomain(
             Longitude.MIN_VALUE + 1, Longitude.MAX_VALUE -  1,
@@ -102,7 +102,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates close to the poles.
-     * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+     * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_POLES = new CoordinateDomain(
             Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -111,23 +111,23 @@ public strictfp class CoordinateDomain {
     {
         @Override
         public double[] generateRandomInput(final Random random, final int dimension, final int numPts) {
-            final double[] ordinates = super.generateRandomInput(random, dimension, numPts);
-            for (int i=1; i < ordinates.length; i += dimension) {
-                final double φ = ordinates[i];
+            final double[] coordinates = super.generateRandomInput(random, dimension, numPts);
+            for (int i=1; i < coordinates.length; i += dimension) {
+                final double φ = coordinates[i];
                 double a = abs(φ);
                 if (a < ARTICLE_CIRCLE) {
                     a -= floor(a / (Latitude.MAX_VALUE - ARTICLE_CIRCLE)) * (Latitude.MAX_VALUE - ARTICLE_CIRCLE);
                     a = (Latitude.MAX_VALUE - a);
-                    ordinates[i] = copySign(a, φ);
+                    coordinates[i] = copySign(a, φ);
                 }
             }
-            return ordinates;
+            return coordinates;
         }
     };
 
     /**
      * Geographic input coordinates close to the north pole.
-     * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+     * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_NORTH_POLE = new CoordinateDomain(
             Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -136,7 +136,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates close to the south pole.
-     * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+     * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_SOUTH_POLE = new CoordinateDomain(
             Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -145,7 +145,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates with angles in radians.
-     * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+     * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_RADIANS = new CoordinateDomain(
             -PI,     PI,
@@ -154,7 +154,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates with angles in radians and only half of the longitude range.
-     * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+     * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_RADIANS_HALF_λ = new CoordinateDomain(
             -PI/2,   PI/2,
@@ -163,7 +163,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates with angles in radians in the North hemisphere only.
-     * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+     * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_RADIANS_NORTH = new CoordinateDomain(
             -PI,     PI,
@@ -172,7 +172,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates with angles in radians in the South hemisphere only.
-     * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+     * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_RADIANS_SOUTH = new CoordinateDomain(
             -PI,     PI,
@@ -181,7 +181,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates with angles in radians in the East hemisphere only.
-     * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+     * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_RADIANS_EAST = new CoordinateDomain(
              0,      PI,
@@ -190,7 +190,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Geographic input coordinates with angles in radians in the West hemisphere only.
-     * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+     * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain GEOGRAPHIC_RADIANS_WEST = new CoordinateDomain(
             -PI,     0,
@@ -199,7 +199,7 @@ public strictfp class CoordinateDomain {
 
     /**
      * Projected input coordinates in a range suitable for UTM projections.
-     * Ordinates are in (<var>easting</var>, <var>northing</var>, <var>height</var>) order.
+     * Coordinates are in (<var>easting</var>, <var>northing</var>, <var>height</var>) order.
      */
     public static final CoordinateDomain PROJECTED = new CoordinateDomain(
              -350000,    350000,    // Easting
@@ -248,10 +248,10 @@ public strictfp class CoordinateDomain {
      * @param  random     the random number generator to use.
      * @param  dimension  the number of dimension of the points to generate.
      * @param  numPts     the number of points to generate.
-     * @return an array of length {@code numPts*dimension} filled with random input ordinate values.
+     * @return an array of length {@code numPts*dimension} filled with random input coordinate values.
      */
     public double[] generateRandomInput(final Random random, final int dimension, final int numPts) {
-        final double[] ordinates = new double[numPts * dimension];
+        final double[] coordinates = new double[numPts * dimension];
         for (int j=0; j<dimension; j++) {
             final double min, max;
             switch (j) {
@@ -259,17 +259,17 @@ public strictfp class CoordinateDomain {
                 case 1:  min = ymin; max = ymax; break;
                 case 2:  min = zmin; max = zmax; break;
                 default: {
-                    for (int i=j; i<ordinates.length; i += dimension) {
-                        ordinates[i] = random.nextGaussian();
+                    for (int i=j; i<coordinates.length; i += dimension) {
+                        coordinates[i] = random.nextGaussian();
                     }
                     continue;
                 }
             }
             final double range = max - min;
-            for (int i=j; i<ordinates.length; i += dimension) {
-                ordinates[i] = min + range * random.nextDouble();
+            for (int i=j; i<coordinates.length; i += dimension) {
+                coordinates[i] = min + range * random.nextDouble();
             }
         }
-        return ordinates;
+        return coordinates;
     }
 }
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java
index 33eaf7d..6b0fdde 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java
@@ -60,9 +60,9 @@ public strictfp class CoordinateDomainTest extends TestCase {
     one can use the following code:
 
     public static void main(String[] args) {
-        double[] ordinates = CoordinateDomain.GEOGRAPHIC.generateRandomInput(new Random(9157324015136982593L), 3, 5));
-        for (int i=0; i<ordinates.length;) {
-            System.out.format(java.util.Locale.US, "            %6.1f, %6.1f, %8.1f,%n", ordinates[i++], ordinates[i++], ordinates[i++]);
+        double[] coordinates = CoordinateDomain.GEOGRAPHIC.generateRandomInput(new Random(9157324015136982593L), 3, 5));
+        for (int i=0; i<coordinates.length;) {
+            System.out.format(java.util.Locale.US, "            %6.1f, %6.1f, %8.1f,%n", coordinates[i++], coordinates[i++], coordinates[i++]);
         }
     }
 */
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java
index 0e6c2eb..d7366cd 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java
@@ -43,7 +43,7 @@ import static org.apache.sis.test.ReferencingAssert.*;
 })
 public final strictfp class CopyTransformTest extends MathTransformTestCase {
     /**
-     * Generates random ordinates with approximately 5% of NaN values in the array.
+     * Generates random coordinates with approximately 5% of NaN values in the array.
      */
     private double[] generateRandomCoordinates() {
         return generateRandomCoordinates(CoordinateDomain.GEOGRAPHIC, 0.05f);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java
index 2c4056d..ae0ba43 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java
@@ -52,7 +52,7 @@ strictfp class PseudoTransform extends AbstractMathTransform {
     protected final int sourceDimension, targetDimension;
 
     /**
-     * Temporary buffer for copying the ordinate of a single source points.
+     * Temporary buffer for copying the coordinates of a single source point.
      * Used in order to be compliant with {@link IterationStrategy} contract.
      */
     private final double[] buffer;
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java b/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java
index b9bd6f4..6776155 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java
@@ -268,7 +268,7 @@ public strictfp class ReferencingAssert extends MetadataAssert {
     }
 
     /**
-     * Asserts that two envelopes have the same minimum and maximum ordinates.
+     * Asserts that two envelopes have the same minimum and maximum coordinates.
      * This method ignores the envelope type (i.e. the implementation class) and the CRS.
      *
      * @param expected    the expected envelope.
@@ -412,14 +412,14 @@ public strictfp class ReferencingAssert extends MetadataAssert {
         for (int index=0; index<numCases; index++) {
             int n = index;
             for (int i=0; i<dimension; i++) {
-                final double ordinate;
+                final double coordinate;
                 switch (n % 3) {
-                    case 0: ordinate = e2.getMinimum(i); break;
-                    case 1: ordinate = e2.getMedian (i); break;
-                    case 2: ordinate = e2.getMaximum(i); break;
+                    case 0: coordinate = e2.getMinimum(i); break;
+                    case 1: coordinate = e2.getMedian (i); break;
+                    case 2: coordinate = e2.getMaximum(i); break;
                     default: throw new AssertionError(i);
                 }
-                pos.setOrdinate(i, ordinate);
+                pos.setOrdinate(i, coordinate);
                 n /= 3;
             }
             assertEquals(0, n); // Opportunist check of this assert method.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java b/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java
index 87281d2..9d64a43 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java
@@ -23,7 +23,7 @@ import org.apache.sis.util.resources.Errors;
 
 
 /**
- * A sequence of {@code DirectPosition}s which is a view over arrays of ordinate values.
+ * A sequence of {@code DirectPosition}s which is a view over arrays of coordinate values.
  * Each dimension is stored in a separated array. For example this class can view three
  * arrays (x[], y[], and z[]) as a sequence of three-dimensional {@code DirectPosition}.
  *
@@ -40,12 +40,12 @@ import org.apache.sis.util.resources.Errors;
  */
 final class CompoundDirectPositions implements DirectPosition, Iterable<DirectPosition>, Iterator<DirectPosition> {
     /**
-     * The arrays of ordinate values, for example (x[], y[], z[]).
+     * The arrays of coordinate values, for example (x[], y[], z[]).
      */
-    private final Vector[] ordinates;
+    private final Vector[] coordinates;
 
     /**
-     * Length of all ordinate values minus one.
+     * Length of all coordinate values minus one.
      */
     private final int last;
 
@@ -55,13 +55,13 @@ final class CompoundDirectPositions implements DirectPosition, Iterable<DirectPo
     private int index;
 
     /**
-     * Wraps the given array of ordinate values.
+     * Wraps the given array of coordinate values.
      */
-    CompoundDirectPositions(final Vector... ordinates) {
-        this.ordinates = ordinates;
-        final int length = ordinates[0].size();
-        for (int i=1; i<ordinates.length; i++) {
-            if (ordinates[i].size() != length) {
+    CompoundDirectPositions(final Vector... coordinates) {
+        this.coordinates = coordinates;
+        final int length = coordinates[0].size();
+        for (int i=1; i<coordinates.length; i++) {
+            if (coordinates[i].size() != length) {
                 throw new IllegalArgumentException(Errors.format(Errors.Keys.MismatchedArrayLengths));
             }
         }
@@ -127,15 +127,15 @@ final class CompoundDirectPositions implements DirectPosition, Iterable<DirectPo
      */
     @Override
     public int getDimension() {
-        return ordinates.length;
+        return coordinates.length;
     }
 
     /**
-     * Return the ordinate value at the given dimension.
+     * Return the coordinate value at the given dimension.
      */
     @Override
     public double getOrdinate(final int dimension) {
-        return ordinates[dimension].doubleValue(index);
+        return coordinates[dimension].doubleValue(index);
     }
 
     /**
diff --git a/core/sis-utility/src/main/java/org/apache/sis/math/Line.java b/core/sis-utility/src/main/java/org/apache/sis/math/Line.java
index 34f38fb..9b3b219 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/math/Line.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/math/Line.java
@@ -231,10 +231,10 @@ public class Line implements DoubleUnaryOperator, Cloneable, Serializable {
      * Sets a line through the specified points.
      * The line will continue toward infinity after the points.
      *
-     * @param  x1  ordinate <var>x</var> of the first point.
-     * @param  y1  ordinate <var>y</var> of the first point.
-     * @param  x2  ordinate <var>x</var> of the second point.
-     * @param  y2  ordinate <var>y</var> of the second point.
+     * @param  x1  coordinate <var>x</var> of the first point.
+     * @param  y1  coordinate <var>y</var> of the first point.
+     * @param  x2  coordinate <var>x</var> of the second point.
+     * @param  y2  coordinate <var>y</var> of the second point.
      */
     public void setFromPoints(final double x1, final double y1, final double x2, final double y2) {
         this.slope = (y2 - y1) / (x2 - x1);
@@ -295,9 +295,9 @@ public class Line implements DoubleUnaryOperator, Cloneable, Serializable {
     /**
      * Given a sequence of points, fits them to a straight line
      * <var>y</var> = <var>slope</var>⋅<var>x</var> + <var>y₀</var> in a least-squares senses.
-     * Points shall be two dimensional with ordinate values in the (<var>x</var>,<var>y</var>) order.
+     * Points shall be two dimensional with coordinate values in the (<var>x</var>,<var>y</var>) order.
      * This method assumes that the <var>x</var> values are precise and all uncertainty is in <var>y</var>.
-     * {@link Double#NaN} ordinate values are ignored.
+     * {@link Double#NaN} coordinate values are ignored.
      *
      * @param  points  the two-dimensional points.
      * @return estimation of the correlation coefficient. The closer this coefficient is to +1 or -1, the better the fit.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java b/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java
index 1583f81..de41015 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java
@@ -248,7 +248,7 @@ public class Plane implements DoubleBinaryOperator, Cloneable, Serializable {
     }
 
     /**
-     * Computes the plane's coefficients from the given ordinate values.
+     * Computes the plane's coefficients from the given coordinate values.
      * This method uses a linear regression in the least-square sense, with the assumption that
      * the (<var>x</var>,<var>y</var>) values are precise and all uncertainty is in <var>z</var>.
      * {@link Double#NaN} values are ignored. The result is undetermined if all points are colinear.
@@ -270,7 +270,7 @@ public class Plane implements DoubleBinaryOperator, Cloneable, Serializable {
     }
 
     /**
-     * Computes the plane's coefficients from the given ordinate values.
+     * Computes the plane's coefficients from the given coordinate values.
      * This method uses a linear regression in the least-square sense, with the assumption that
      * the (<var>x</var>,<var>y</var>) values are precise and all uncertainty is in <var>z</var>.
      * {@link Double#NaN} values are ignored. The result is undetermined if all points are colinear.
@@ -355,7 +355,7 @@ public class Plane implements DoubleBinaryOperator, Cloneable, Serializable {
      * Computes the plane's coefficients from the given sequence of points.
      * This method uses a linear regression in the least-square sense, with the assumption that
      * the (<var>x</var>,<var>y</var>) values are precise and all uncertainty is in <var>z</var>.
-     * Points shall be three dimensional with ordinate values in the (<var>x</var>,<var>y</var>,<var>z</var>) order.
+     * Points shall be three dimensional with coordinate values in the (<var>x</var>,<var>y</var>,<var>z</var>) order.
      * {@link Double#NaN} values are ignored. The result is undetermined if all points are colinear.
      *
      * @param  points  the three-dimensional points.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java b/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java
index 8b57fe3..90b313d 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java
@@ -115,8 +115,8 @@ public final class Latitude extends Angle {
      * {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS};
      * it may also be <cite>geocentric latitudes</cite>.
      *
-     * <p>If the axis direction is South, then the sign of the ordinate value is inverted.
-     * If the ordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
+     * <p>If the axis direction is South, then the sign of the coordinate value is inverted.
+     * If the coordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
      * then a unit conversion is applied.</p>
      *
      * @param  position  the coordinate from which to extract the latitude value in degrees.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java b/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java
index 97eeca4..9a84754 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java
@@ -102,8 +102,8 @@ public final class Longitude extends Angle {
      * {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS};
      * it may also be <cite>geocentric longitudes</cite>.
      *
-     * <p>If the axis direction is West, then the sign of the ordinate value is inverted.
-     * If the ordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
+     * <p>If the axis direction is West, then the sign of the coordinate value is inverted.
+     * If the coordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
      * then a unit conversion is applied.</p>
      *
      * @param  position  the coordinate from which to extract the longitude value in degrees.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
index ca225f8..80a841c 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
@@ -368,6 +368,11 @@ public final class Errors extends IndexedResourceBundle {
         public static final short IllegalClass_2 = 50;
 
         /**
+         * The [{0} … {1}] range of coordinate values is not valid for the “{2}” axis.
+         */
+        public static final short IllegalCoordinateRange_3 = 57;
+
+        /**
          * Coordinate system can not be “{0}”.
          */
         public static final short IllegalCoordinateSystem_1 = 51;
@@ -403,11 +408,6 @@ public final class Errors extends IndexedResourceBundle {
         public static final short IllegalOptionValue_2 = 56;
 
         /**
-         * The [{0} … {1}] range of ordinate values is not valid for the “{2}” axis.
-         */
-        public static final short IllegalOrdinateRange_3 = 57;
-
-        /**
          * Property “{0}” does not accept instances of ‘{1}’.
          */
         public static final short IllegalPropertyValueClass_2 = 58;
diff --git a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
index 1b4f467..b69913a 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
+++ b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
@@ -91,7 +91,7 @@ IllegalLanguageCode_1             = The \u201c{0}\u201d language is not recogniz
 IllegalMapping_2                  = Illegal mapping: {0} \u2192 {1}.
 IllegalMemberType_2               = Member \u201c{0}\u201d can not be associated to type \u201c{1}\u201d.
 IllegalOptionValue_2              = Option \u2018{0}\u2019 can not take the \u201c{1}\u201d value.
-IllegalOrdinateRange_3            = The [{0} \u2026 {1}] range of ordinate values is not valid for the \u201c{2}\u201d axis.
+IllegalCoordinateRange_3          = The [{0} \u2026 {1}] range of coordinate values is not valid for the \u201c{2}\u201d axis.
 IllegalPropertyValueClass_2       = Property \u201c{0}\u201d does not accept instances of \u2018{1}\u2019.
 IllegalPropertyValueClass_3       = Expected an instance of \u2018{1}\u2019 for the \u201c{0}\u201d property, but got an instance of \u2018{2}\u2019.
 IllegalRange_2                    = Range [{0} \u2026 {1}] is not valid.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
index fe58d55..8bc217f 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
+++ b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
@@ -88,7 +88,7 @@ IllegalLanguageCode_1             = Le code de langue \u00ab\u202f{0}\u202f\u00b
 IllegalMapping_2                  = Correspondance ill\u00e9gale: {0} \u2192 {1}.
 IllegalMemberType_2               = Le membre \u00ab\u202f{0}\u202f\u00bb ne peut pas \u00eatre associ\u00e9 au type \u00ab\u202f{1}\u202f\u00bb.
 IllegalOptionValue_2              = L\u2019option \u2018{0}\u2019 n\u2019accepte pas la valeur \u00ab\u202f{1}\u202f\u00bb.
-IllegalOrdinateRange_3            = La plage de valeurs de coordonn\u00e9es [{0} \u2026 {1}] n\u2019est pas valide pour l\u2019axe \u00ab\u202f{2}\u202f\u00bb.
+IllegalCoordinateRange_3          = La plage de valeurs de coordonn\u00e9es [{0} \u2026 {1}] n\u2019est pas valide pour l\u2019axe \u00ab\u202f{2}\u202f\u00bb.
 IllegalPropertyValueClass_2       = La propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb n\u2019accepte pas les valeurs de type \u2018{1}\u2019.
 IllegalPropertyValueClass_3       = Une instance \u2018{1}\u2019 \u00e9tait attendue pour la propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb, mais la valeur donn\u00e9e est une instance de \u2018{2}\u2019.
 IllegalRange_2                    = La plage [{0} \u2026 {1}] n\u2019est pas valide.
diff --git a/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java b/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java
index 5008a2d..f4823ac 100644
--- a/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java
+++ b/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java
@@ -363,9 +363,9 @@ public final strictfp class TestUtilities extends Static {
     }
 
     /**
-     * Returns a copy of the given array with the last ordinate values dropped for each coordinates.
+     * Returns a copy of the given array with the last coordinate values dropped for each coordinates.
      *
-     * @param  coordinates  the source coordinates from which to drop the last ordinate values.
+     * @param  coordinates  the source coordinates from which to drop the last coordinate values.
      * @param  sourceDim    number of dimensions of each point in the {@code coordinates} array.
      * @param  targetDim    number of dimensions to retain.
      * @return copy of the given {@code coordinates} array with only the {@code targetDim} first dimension for each point.
diff --git a/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java b/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java
index 31dc007..cd7e610 100644
--- a/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java
+++ b/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java
@@ -142,7 +142,7 @@ final class LandsatReader extends MetadataBuilder {
     static final Pattern CREDIT = Pattern.compile("\\bcourtesy\\h+of\\h+(the)?\\b\\s*", Pattern.CASE_INSENSITIVE);
 
     /**
-     * Number of spatial dimensions. This is the number of ordinate values to be stored
+     * Number of spatial dimensions. This is the number of coordinate values to be stored
      * in the {@link #gridSizes} and {@link #corners} arrays for each tuple.
      */
     static final int DIM = 2;
@@ -192,7 +192,7 @@ final class LandsatReader extends MetadataBuilder {
 
     /**
      * Index of projected and geographic coordinates in the {@link #corners} array.
-     * Each kind of coordinates are stored as 4 corners of {@value #DIM} ordinate values.
+     * Each kind of coordinates are stored as 4 corners of {@value #DIM} coordinate values.
      */
     private static final int PROJECTED  = 0*DIM,
                              GEOGRAPHIC = 4*DIM;
@@ -390,7 +390,7 @@ final class LandsatReader extends MetadataBuilder {
     /**
      * Parses the given value and stores it at the given index in the {@link #corners} array.
      * The given index must be one of the {@link #PROJECTED} or {@link #GEOGRAPHIC} constants
-     * plus the ordinate index.
+     * plus the coordinate index.
      */
     private void parseCorner(final int index, final String value) throws NumberFormatException {
         corners[index] = Double.parseDouble(value);
diff --git a/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c b/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c
index 9ae2b15..329dc4c 100644
--- a/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c
+++ b/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c
@@ -194,10 +194,10 @@ JNIEXPORT jdoubleArray JNICALL Java_org_apache_sis_storage_gdal_PJ_getEllipsoidD
 void convertAngularOrdinates(projPJ pj, double* data, jint numPts, int dimension, double factor) {
     int dimToSkip;
     if (pj_is_latlong(pj)) {
-        // Convert only the 2 first ordinates and skip all the other dimensions.
+        // Convert only the 2 first coordinates and skip all the other dimensions.
         dimToSkip = dimension - 2;
     } else if (pj_is_geocent(pj)) {
-        // Convert only the 3 first ordinates and skip all the other dimensions.
+        // Convert only the 3 first coordinates and skip all the other dimensions.
         dimToSkip = dimension - 3;
     } else {
         // Not a geographic or geocentric CRS: nothing to convert.
diff --git a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java
index 06fd23d..b54c5c4 100644
--- a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java
+++ b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java
@@ -106,9 +106,9 @@ final class GridGeometryBuilder {
     public String asciiParameters;
 
     /**
-     * Raster model tie points. This vector contains ordinate values structured as (I,J,K, X,Y,Z) records.
-     * The (I,J,K) ordinate values specify the point at location (I,J) in raster space with pixel-value K,
-     * and (X,Y,Z) ordinate values specify the point in the Coordinate Reference System. In most cases the
+     * Raster model tie points. This vector contains coordinate values structured as (I,J,K, X,Y,Z) records.
+     * The (I,J,K) coordinate values specify the point at location (I,J) in raster space with pixel-value K,
+     * and (X,Y,Z) coordinate values specify the point in the Coordinate Reference System. In most cases the
      * coordinate system is only two-dimensional, in which case both K and Z should be set to zero.
      */
     public Vector modelTiePoints;
diff --git a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java
index 799cea5..06c6967 100644
--- a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java
+++ b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java
@@ -92,13 +92,13 @@ final class Localization {
         try {
             final LocalizationGridBuilder grid = new LocalizationGridBuilder(x, y);
             final LinearTransform sourceToGrid = grid.getSourceToGrid();
-            final double[] ordinates = new double[2];
+            final double[] coordinates = new double[2];
             for (int i=0; i<size; i += RECORD_LENGTH) {
-                ordinates[0] = modelTiePoints.doubleValue(i);
-                ordinates[1] = modelTiePoints.doubleValue(i+1);
-                sourceToGrid.transform(ordinates, 0, ordinates, 0, 1);
-                grid.setControlPoint(Math.toIntExact(Math.round(ordinates[0])),
-                                     Math.toIntExact(Math.round(ordinates[1])),
+                coordinates[0] = modelTiePoints.doubleValue(i);
+                coordinates[1] = modelTiePoints.doubleValue(i+1);
+                sourceToGrid.transform(coordinates, 0, coordinates, 0, 1);
+                grid.setControlPoint(Math.toIntExact(Math.round(coordinates[0])),
+                                     Math.toIntExact(Math.round(coordinates[1])),
                                      modelTiePoints.doubleValue(i + (RECORD_LENGTH/2)),
                                      modelTiePoints.doubleValue(i + (RECORD_LENGTH/2 + 1)));
             }
diff --git a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java
index 7725d43..cfd0cbd 100644
--- a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java
+++ b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java
@@ -306,7 +306,7 @@ next:       for (final String name : axisNames) {
             }
             /*
              * Get the grid dimensions (part of the "domain" in UCAR terminology) used for computing
-             * the ordinate values along the current axis. There is exactly 1 such grid dimension in
+             * the coordinate values along the current axis. There is exactly 1 such grid dimension in
              * straightforward netCDF files. However some more complex files may have 2 dimensions.
              */
             int i = 0;
diff --git a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java
index 37d56e4..b8b6df1 100644
--- a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java
+++ b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java
@@ -256,7 +256,7 @@ next:       for (final String name : axisNames) {
             }
             /*
              * Get the grid dimensions (part of the "domain" in UCAR terminology) used for computing
-             * the ordinate values along the current axis. There is exactly 1 such grid dimension in
+             * the coordinate values along the current axis. There is exactly 1 such grid dimension in
              * straightforward netCDF files. However some more complex files may have 2 dimensions.
              */
             int i = 0;
diff --git a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java
index 1afdc34..133c6ea 100644
--- a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java
+++ b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java
@@ -1792,13 +1792,13 @@ parse:      for (int i = 0; i < length;) {
      *   <li>{@code metadata/identificationInfo/extent/geographicElement}</li>
      * </ul>
      *
-     * @param  ordinates  the geographic coordinates, or {@code null} for no-operation.
-     * @param  index      index of the first value to use in the given array.
+     * @param  coordinates  the geographic coordinates, or {@code null} for no-operation.
+     * @param  index        index of the first value to use in the given array.
      */
-    public final void addExtent(final double[] ordinates, int index) {
-        if (ordinates != null) {
+    public final void addExtent(final double[] coordinates, int index) {
+        if (coordinates != null) {
             final DefaultGeographicBoundingBox bbox = new DefaultGeographicBoundingBox(
-                        ordinates[index], ordinates[++index], ordinates[++index], ordinates[++index]);
+                        coordinates[index], coordinates[++index], coordinates[++index], coordinates[++index]);
             if (!bbox.isEmpty()) {
                 addIfNotPresent(extent().getGeographicElements(), bbox);
             }
diff --git a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java
index 7895203..caa298a 100644
--- a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java
+++ b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java
@@ -115,7 +115,7 @@ final class Store extends URIDataStore implements FeatureSet {
     static final char SEPARATOR = ',';
 
     /**
-     * The separator between ordinate values in a coordinate.
+     * The separator between coordinate values in a coordinate tuple.
      */
     static final char ORDINATE_SEPARATOR = ' ';
 


Mime
View raw message