asfgit closed pull request #3: GEOMETRY-6: Making CartesianXD fields private
URL: https://github.com/apache/commons-geometry/pull/3
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Cartesian1D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Cartesian1D.java
index 7cfbf9d..53e2879 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Cartesian1D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Cartesian1D.java
@@ -27,7 +27,7 @@
private static final long serialVersionUID = -1178039568877797126L;
/** Abscissa (coordinate value). */
- protected final double x;
+ private final double x;
/**
* Simple constructor.
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Point1D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Point1D.java
index 8983598..eeeed9f 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Point1D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Point1D.java
@@ -63,13 +63,13 @@ public Vector1D asVector() {
/** {@inheritDoc} */
@Override
public double distance(Point1D p) {
- return Math.abs(p.x - x);
+ return Math.abs(p.getX() - getX());
}
/** {@inheritDoc} */
@Override
public Vector1D subtract(Point1D p) {
- return Vector1D.of(x - p.x);
+ return Vector1D.of(getX() - p.getX());
}
/** {@inheritDoc} */
@@ -81,7 +81,7 @@ public Vector1D vectorTo(Point1D p) {
/** {@inheritDoc} */
@Override
public Point1D add(Vector1D v) {
- return new Point1D(x + v.x);
+ return new Point1D(getX() + v.getX());
}
/**
@@ -95,7 +95,7 @@ public int hashCode() {
if (isNaN()) {
return 7785;
}
- return 997 * Double.hashCode(x);
+ return 997 * Double.hashCode(getX());
}
/**
@@ -129,7 +129,7 @@ public boolean equals(Object other) {
return this.isNaN();
}
- return x == rhs.x;
+ return getX() == rhs.getX();
}
return false;
}
@@ -137,7 +137,7 @@ public boolean equals(Object other) {
/** {@inheritDoc} */
@Override
public String toString() {
- return "(" + x + ")";
+ return "(" + getX() + ")";
}
/** Returns a point with the given coordinate value.
@@ -153,7 +153,7 @@ public static Point1D of(double x) {
* @return point instance
*/
public static Point1D of(Cartesian1D value) {
- return new Point1D(value.x);
+ return new Point1D(value.getX());
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -176,7 +176,7 @@ public static Point1D of(Cartesian1D value) {
* @see {@link Vector1D#linearCombination(double, Vector1D)}
*/
public static Point1D vectorCombination(double a, Cartesian1D c) {
- return new Point1D(a * c.x);
+ return new Point1D(a * c.getX());
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -202,7 +202,7 @@ public static Point1D vectorCombination(double a,
Cartesian1D c) {
*/
public static Point1D vectorCombination(double a1, Cartesian1D c1, double
a2, Cartesian1D c2) {
return new Point1D(
- LinearCombination.value(a1, c1.x, a2, c2.x));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX()));
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -231,7 +231,7 @@ public static Point1D vectorCombination(double a1,
Cartesian1D c1, double a2, Ca
public static Point1D vectorCombination(double a1, Cartesian1D c1, double
a2, Cartesian1D c2,
double a3, Cartesian1D c3) {
return new Point1D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX()));
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -262,6 +262,6 @@ public static Point1D vectorCombination(double a1,
Cartesian1D c1, double a2, Ca
public static Point1D vectorCombination(double a1, Cartesian1D c1, double
a2, Cartesian1D c2,
double a3, Cartesian1D c3, double a4, Cartesian1D c4) {
return new Point1D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x, a4,
c4.x));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX(), a4, c4.getX()));
}
}
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java
index f2adbad..1e6ab7d 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java
@@ -74,13 +74,13 @@ public double getNorm1() {
/** {@inheritDoc} */
@Override
public double getNorm() {
- return Math.abs(x);
+ return Math.abs(getX());
}
/** {@inheritDoc} */
@Override
public double getNormSq() {
- return x * x;
+ return getX() * getX();
}
/** {@inheritDoc} */
@@ -92,31 +92,31 @@ public double getNormInf() {
/** {@inheritDoc} */
@Override
public Vector1D add(Vector1D v) {
- return new Vector1D(x + v.x);
+ return new Vector1D(getX() + v.getX());
}
/** {@inheritDoc} */
@Override
public Vector1D add(double factor, Vector1D v) {
- return new Vector1D(x + (factor * v.x));
+ return new Vector1D(getX() + (factor * v.getX()));
}
/** {@inheritDoc} */
@Override
public Vector1D subtract(Vector1D v) {
- return new Vector1D(x - v.x);
+ return new Vector1D(getX() - v.getX());
}
/** {@inheritDoc} */
@Override
public Vector1D subtract(double factor, Vector1D v) {
- return new Vector1D(x - (factor * v.x));
+ return new Vector1D(getX() - (factor * v.getX()));
}
/** {@inheritDoc} */
@Override
public Vector1D negate() {
- return new Vector1D(-x);
+ return new Vector1D(-getX());
}
/** {@inheritDoc} */
@@ -132,7 +132,7 @@ public Vector1D normalize() throws IllegalStateException {
/** {@inheritDoc} */
@Override
public Vector1D scalarMultiply(double a) {
- return new Vector1D(a * x);
+ return new Vector1D(a * getX());
}
/** {@inheritDoc} */
@@ -144,7 +144,7 @@ public double distance1(Vector1D v) {
/** {@inheritDoc} */
@Override
public double distance(Vector1D v) {
- return Math.abs(v.x - x);
+ return Math.abs(v.getX() - getX());
}
/** {@inheritDoc} */
@@ -156,14 +156,14 @@ public double distanceInf(Vector1D v) {
/** {@inheritDoc} */
@Override
public double distanceSq(Vector1D v) {
- final double dx = v.x - x;
+ final double dx = v.getX() - getX();
return dx * dx;
}
/** {@inheritDoc} */
@Override
public double dotProduct(Vector1D v) {
- return x * v.x;
+ return getX() * v.getX();
}
/**
@@ -177,7 +177,7 @@ public int hashCode() {
if (isNaN()) {
return 857;
}
- return 403 * Double.hashCode(x);
+ return 403 * Double.hashCode(getX());
}
/**
@@ -212,7 +212,7 @@ public boolean equals(Object other) {
return this.isNaN();
}
- return x == rhs.x;
+ return getX() == rhs.getX();
}
return false;
}
@@ -220,7 +220,7 @@ public boolean equals(Object other) {
/** {@inheritDoc} */
@Override
public String toString() {
- return "{" + x + "}";
+ return "{" + getX() + "}";
}
/** Returns a vector with the given coordinate value.
@@ -236,7 +236,7 @@ public static Vector1D of(double x) {
* @return vector instance
*/
public static Vector1D of(Cartesian1D value) {
- return new Vector1D(value.x);
+ return new Vector1D(value.getX());
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -252,7 +252,7 @@ public static Vector1D of(Cartesian1D value) {
* @return vector with coordinates calculated by {@code a * c}
*/
public static Vector1D linearCombination(double a, Cartesian1D c) {
- return new Vector1D(a * c.x);
+ return new Vector1D(a * c.getX());
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -271,7 +271,7 @@ public static Vector1D linearCombination(double a,
Cartesian1D c) {
*/
public static Vector1D linearCombination(double a1, Cartesian1D c1, double
a2, Cartesian1D c2) {
return new Vector1D(
- LinearCombination.value(a1, c1.x, a2, c2.x));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX()));
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -293,7 +293,7 @@ public static Vector1D linearCombination(double a1,
Cartesian1D c1, double a2, C
public static Vector1D linearCombination(double a1, Cartesian1D c1, double
a2, Cartesian1D c2,
double a3, Cartesian1D c3) {
return new Vector1D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX()));
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -317,6 +317,6 @@ public static Vector1D linearCombination(double a1,
Cartesian1D c1, double a2, C
public static Vector1D linearCombination(double a1, Cartesian1D c1, double
a2, Cartesian1D c2,
double a3, Cartesian1D c3, double a4, Cartesian1D c4) {
return new Vector1D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x, a4,
c4.x));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX(), a4, c4.getX()));
}
}
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Cartesian3D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Cartesian3D.java
index b57c108..4640b23 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Cartesian3D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Cartesian3D.java
@@ -28,13 +28,13 @@
private static final long serialVersionUID = 6249091865814886817L;
/** Abscissa (first coordinate value) */
- protected final double x;
+ private final double x;
/** Ordinate (second coordinate value) */
- protected final double y;
+ private final double y;
/** Height (third coordinate value)*/
- protected final double z;
+ private final double z;
/** Simple constructor.
* @param x abscissa (first coordinate value)
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Point3D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Point3D.java
index a91f03e..46de33d 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Point3D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Point3D.java
@@ -57,7 +57,7 @@ public Point3D(double x, double y, double z) {
/** {@inheritDoc} */
@Override
public Vector3D asVector() {
- return Vector3D.of(x, y, z);
+ return Vector3D.of(getX(), getY(), getZ());
}
/** {@inheritDoc} */
@@ -70,9 +70,9 @@ public double distance(Point3D p) {
@Override
public Vector3D subtract(Point3D p) {
return new Vector3D(
- x - p.x,
- y - p.y,
- z - p.z
+ getX() - p.getX(),
+ getY() - p.getY(),
+ getZ() - p.getZ()
);
}
@@ -86,9 +86,9 @@ public Vector3D vectorTo(Point3D p) {
@Override
public Point3D add(Vector3D v) {
return new Point3D(
- x + v.x,
- y + v.y,
- z + v.z
+ getX() + v.getX(),
+ getY() + v.getY(),
+ getZ() + v.getZ()
);
}
@@ -103,7 +103,7 @@ public int hashCode() {
if (isNaN()) {
return 642;
}
- return 643 * (164 * Double.hashCode(x) + 3 * Double.hashCode(y) +
Double.hashCode(z));
+ return 643 * (164 * Double.hashCode(getX()) + 3 *
Double.hashCode(getY()) + Double.hashCode(getZ()));
}
/** Test for the equality of two points.
@@ -137,7 +137,7 @@ public boolean equals(Object other) {
return this.isNaN();
}
- return (x == rhs.x) && (y == rhs.y) && (z == rhs.z);
+ return (getX() == rhs.getX()) && (getY() == rhs.getY()) && (getZ()
== rhs.getZ());
}
return false;
}
@@ -145,7 +145,7 @@ public boolean equals(Object other) {
/** {@inheritDoc} */
@Override
public String toString() {
- return "(" + x + "; " + y + "; " + z + ")";
+ return "(" + getX() + "; " + getY() + "; " + getZ() + ")";
}
/** Returns a point with the given coordinate values
@@ -163,7 +163,7 @@ public static Point3D of(double x, double y, double z) {
* @return point instance
*/
public static Point3D of(Cartesian3D value) {
- return new Point3D(value.x, value.y, value.z);
+ return new Point3D(value.getX(), value.getY(), value.getZ());
}
/** Creates a point from the coordinates in the given 3-element array.
@@ -197,7 +197,7 @@ public static Point3D of(double[] p) {
* @return point with coordinates calculated by {@code a * c}
*/
public static Point3D vectorCombination(double a, Cartesian3D c) {
- return new Point3D(a * c.x, a * c.y, a * c.z);
+ return new Point3D(a * c.getX(), a * c.getY(), a * c.getZ());
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -222,9 +222,9 @@ public static Point3D vectorCombination(double a,
Cartesian3D c) {
*/
public static Point3D vectorCombination(double a1, Cartesian3D c1, double
a2, Cartesian3D c2) {
return new Point3D(
- LinearCombination.value(a1, c1.x, a2, c2.x),
- LinearCombination.value(a1, c1.y, a2, c2.y),
- LinearCombination.value(a1, c1.z, a2, c2.z));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY()),
+ LinearCombination.value(a1, c1.getZ(), a2, c2.getZ()));
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -252,9 +252,9 @@ public static Point3D vectorCombination(double a1,
Cartesian3D c1, double a2, Ca
public static Point3D vectorCombination(double a1, Cartesian3D c1, double
a2, Cartesian3D c2,
double a3, Cartesian3D c3) {
return new Point3D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y),
- LinearCombination.value(a1, c1.z, a2, c2.z, a3, c3.z));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY()),
+ LinearCombination.value(a1, c1.getZ(), a2, c2.getZ(), a3,
c3.getZ()));
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -284,8 +284,8 @@ public static Point3D vectorCombination(double a1,
Cartesian3D c1, double a2, Ca
public static Point3D vectorCombination(double a1, Cartesian3D c1, double
a2, Cartesian3D c2,
double a3, Cartesian3D c3, double a4, Cartesian3D c4) {
return new Point3D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x, a4,
c4.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y, a4,
c4.y),
- LinearCombination.value(a1, c1.z, a2, c2.z, a3, c3.z, a4,
c4.z));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX(), a4, c4.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY(), a4, c4.getY()),
+ LinearCombination.value(a1, c1.getZ(), a2, c2.getZ(), a3,
c3.getZ(), a4, c4.getZ()));
}
}
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java
index 9e9d39d..5a9e0ac 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java
@@ -83,19 +83,22 @@ public Vector3D getZero() {
/** {@inheritDoc} */
@Override
public Point3D asPoint() {
- return Point3D.of(x, y, z);
+ return Point3D.of(getX(), getY(), getZ());
}
/** {@inheritDoc} */
@Override
public double getNorm1() {
- return Math.abs(x) + Math.abs(y) + Math.abs(z);
+ return Math.abs(getX()) + Math.abs(getY()) + Math.abs(getZ());
}
/** {@inheritDoc} */
@Override
public double getNorm() {
// there are no cancellation problems here, so we use the
straightforward formula
+ final double x = getX();
+ final double y = getY();
+ final double z = getZ();
return Math.sqrt ((x * x) + (y * y) + (z * z));
}
@@ -103,36 +106,39 @@ public double getNorm() {
@Override
public double getNormSq() {
// there are no cancellation problems here, so we use the
straightforward formula
+ final double x = getX();
+ final double y = getY();
+ final double z = getZ();
return (x * x) + (y * y) + (z * z);
}
/** {@inheritDoc} */
@Override
public double getNormInf() {
- return Math.max(Math.max(Math.abs(x), Math.abs(y)), Math.abs(z));
+ return Math.max(Math.max(Math.abs(getX()), Math.abs(getY())),
Math.abs(getZ()));
}
/** Get the azimuth of the vector.
* @return azimuth (α) of the vector, between -π and +π
*/
public double getAlpha() {
- return Math.atan2(y, x);
+ return Math.atan2(getY(), getX());
}
/** Get the elevation of the vector.
* @return elevation (δ) of the vector, between -π/2 and +π/2
*/
public double getDelta() {
- return Math.asin(z / getNorm());
+ return Math.asin(getZ() / getNorm());
}
/** {@inheritDoc} */
@Override
public Vector3D add(Vector3D v) {
return new Vector3D(
- x + v.x,
- y + v.y,
- z + v.z
+ getX() + v.getX(),
+ getY() + v.getY(),
+ getZ() + v.getZ()
);
}
@@ -140,9 +146,9 @@ public Vector3D add(Vector3D v) {
@Override
public Vector3D add(double factor, Vector3D v) {
return new Vector3D(
- x + (factor * v.x),
- y + (factor * v.y),
- z + (factor * v.z)
+ getX() + (factor * v.getX()),
+ getY() + (factor * v.getY()),
+ getZ() + (factor * v.getZ())
);
}
@@ -150,9 +156,9 @@ public Vector3D add(double factor, Vector3D v) {
@Override
public Vector3D subtract(Vector3D v) {
return new Vector3D(
- x - v.x,
- y - v.y,
- z - v.z
+ getX() - v.getX(),
+ getY() - v.getY(),
+ getZ() - v.getZ()
);
}
@@ -160,16 +166,16 @@ public Vector3D subtract(Vector3D v) {
@Override
public Vector3D subtract(double factor, Vector3D v) {
return new Vector3D(
- x - (factor * v.x),
- y - (factor * v.y),
- z - (factor * v.z)
+ getX() - (factor * v.getX()),
+ getY() - (factor * v.getY()),
+ getZ() - (factor * v.getZ())
);
}
/** {@inheritDoc} */
@Override
public Vector3D negate() {
- return new Vector3D(-x, -y, -z);
+ return new Vector3D(-getX(), -getY(), -getZ());
}
/** {@inheritDoc} */
@@ -203,6 +209,10 @@ public Vector3D orthogonal() throws IllegalStateException {
throw new IllegalStateException(ZERO_NORM_MSG);
}
+ final double x = getX();
+ final double y = getY();
+ final double z = getZ();
+
if (Math.abs(x) <= threshold) {
double inverse = 1 / Math.sqrt(y * y + z * z);
return new Vector3D(0, inverse * z, -inverse * y);
@@ -250,23 +260,23 @@ public double angle(Vector3D v) throws
IllegalStateException {
* @return the cross product this ^ v as a new Cartesian3D
*/
public Vector3D crossProduct(final Vector3D v) {
- return new Vector3D(LinearCombination.value(y, v.z, -z, v.y),
- LinearCombination.value(z, v.x, -x, v.z),
- LinearCombination.value(x, v.y, -y, v.x));
+ return new Vector3D(LinearCombination.value(getY(), v.getZ(), -getZ(),
v.getY()),
+ LinearCombination.value(getZ(), v.getX(), -getX(),
v.getZ()),
+ LinearCombination.value(getX(), v.getY(), -getY(),
v.getX()));
}
/** {@inheritDoc} */
@Override
public Vector3D scalarMultiply(double a) {
- return new Vector3D(a * x, a * y, a * z);
+ return new Vector3D(a * getX(), a * getY(), a * getZ());
}
/** {@inheritDoc} */
@Override
public double distance1(Vector3D v) {
- double dx = Math.abs(v.x - x);
- double dy = Math.abs(v.y - y);
- double dz = Math.abs(v.z - z);
+ double dx = Math.abs(v.getX() - getX());
+ double dy = Math.abs(v.getY() - getY());
+ double dz = Math.abs(v.getZ() - getZ());
return dx + dy + dz;
}
@@ -280,9 +290,9 @@ public double distance(Vector3D v) {
/** {@inheritDoc} */
@Override
public double distanceInf(Vector3D v) {
- double dx = Math.abs(v.x - x);
- double dy = Math.abs(v.y - y);
- double dz = Math.abs(v.z - z);
+ double dx = Math.abs(v.getX() - getX());
+ double dy = Math.abs(v.getY() - getY());
+ double dz = Math.abs(v.getZ() - getZ());
return Math.max(Math.max(dx, dy), dz);
}
@@ -290,9 +300,9 @@ public double distanceInf(Vector3D v) {
/** {@inheritDoc} */
@Override
public double distanceSq(Vector3D v) {
- double dx = v.x - x;
- double dy = v.y - y;
- double dz = v.z - z;
+ double dx = v.getX() - getX();
+ double dy = v.getY() - getY();
+ double dz = v.getZ() - getZ();
return (dx * dx) + (dy * dy) + (dz * dz);
}
@@ -307,7 +317,7 @@ public double distanceSq(Vector3D v) {
*/
@Override
public double dotProduct(Vector3D v) {
- return LinearCombination.value(x, v.x, y, v.y, z, v.z);
+ return LinearCombination.value(getX(), v.getX(), getY(), v.getY(),
getZ(), v.getZ());
}
/**
@@ -321,7 +331,7 @@ public int hashCode() {
if (isNaN()) {
return 642;
}
- return 643 * (164 * Double.hashCode(x) + 3 * Double.hashCode(y) +
Double.hashCode(z));
+ return 643 * (164 * Double.hashCode(getX()) + 3 *
Double.hashCode(getY()) + Double.hashCode(getZ()));
}
/**
@@ -355,7 +365,7 @@ public boolean equals(Object other) {
return this.isNaN();
}
- return (x == rhs.x) && (y == rhs.y) && (z == rhs.z);
+ return (getX() == rhs.getX()) && (getY() == rhs.getY()) && (getZ()
== rhs.getZ());
}
return false;
}
@@ -363,7 +373,7 @@ public boolean equals(Object other) {
/** {@inheritDoc} */
@Override
public String toString() {
- return "{" + x + "; " + y + "; " + z + "}";
+ return "{" + getX() + "; " + getY() + "; " + getZ() + "}";
}
/** Computes the dot product between to vectors. This method simply
@@ -414,7 +424,7 @@ public static Vector3D of(double x, double y, double z) {
* @return vector instance
*/
public static Vector3D of(Cartesian3D value) {
- return new Vector3D(value.x, value.y, value.z);
+ return new Vector3D(value.getX(), value.getY(), value.getZ());
}
/** Creates a vector from the coordinates in the given 3-element array.
@@ -461,7 +471,7 @@ public static Vector3D fromSpherical(double alpha, double
delta) {
* @return vector with coordinates calculated by {@code a * c}
*/
public static Vector3D linearCombination(double a, Cartesian3D c) {
- return new Vector3D(a * c.x, a * c.y, a * c.z);
+ return new Vector3D(a * c.getX(), a * c.getY(), a * c.getZ());
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -480,9 +490,9 @@ public static Vector3D linearCombination(double a,
Cartesian3D c) {
*/
public static Vector3D linearCombination(double a1, Cartesian3D c1, double
a2, Cartesian3D c2) {
return new Vector3D(
- LinearCombination.value(a1, c1.x, a2, c2.x),
- LinearCombination.value(a1, c1.y, a2, c2.y),
- LinearCombination.value(a1, c1.z, a2, c2.z));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY()),
+ LinearCombination.value(a1, c1.getZ(), a2, c2.getZ()));
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -504,9 +514,9 @@ public static Vector3D linearCombination(double a1,
Cartesian3D c1, double a2, C
public static Vector3D linearCombination(double a1, Cartesian3D c1, double
a2, Cartesian3D c2,
double a3, Cartesian3D c3) {
return new Vector3D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y),
- LinearCombination.value(a1, c1.z, a2, c2.z, a3, c3.z));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY()),
+ LinearCombination.value(a1, c1.getZ(), a2, c2.getZ(), a3,
c3.getZ()));
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -530,8 +540,8 @@ public static Vector3D linearCombination(double a1,
Cartesian3D c1, double a2, C
public static Vector3D linearCombination(double a1, Cartesian3D c1, double
a2, Cartesian3D c2,
double a3, Cartesian3D c3, double a4, Cartesian3D c4) {
return new Vector3D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x, a4,
c4.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y, a4,
c4.y),
- LinearCombination.value(a1, c1.z, a2, c2.z, a3, c3.z, a4,
c4.z));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX(), a4, c4.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY(), a4, c4.getY()),
+ LinearCombination.value(a1, c1.getZ(), a2, c2.getZ(), a3,
c3.getZ(), a4, c4.getZ()));
}
}
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Cartesian2D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Cartesian2D.java
index 29aedcd..ba3b462 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Cartesian2D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Cartesian2D.java
@@ -28,10 +28,10 @@
private static final long serialVersionUID = 2918583078965478552L;
/** Abscissa (first coordinate) */
- protected final double x;
+ private final double x;
/** Ordinate (second coordinate) */
- protected final double y;
+ private final double y;
/**
* Simple Cartesian constructor.
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Point2D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Point2D.java
index 2d73d72..e062b89 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Point2D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Point2D.java
@@ -55,7 +55,7 @@ public Point2D(double x, double y) {
/** {@inheritDoc} */
@Override
public Vector2D asVector() {
- return new Vector2D(x, y);
+ return new Vector2D(getX(), getY());
}
/** {@inheritDoc} */
@@ -67,7 +67,7 @@ public double distance(Point2D p) {
/** {@inheritDoc} */
@Override
public Vector2D subtract(Point2D p) {
- return Vector2D.of(x - p.x, y - p.y);
+ return Vector2D.of(getX() - p.getX(), getY() - p.getY());
}
/** {@inheritDoc} */
@@ -79,7 +79,7 @@ public Vector2D vectorTo(Point2D p) {
/** {@inheritDoc} */
@Override
public Point2D add(Vector2D v) {
- return new Point2D(x + v.x, y + v.y);
+ return new Point2D(getX() + v.getX(), getY() + v.getY());
}
/**
@@ -93,7 +93,7 @@ public int hashCode() {
if (isNaN()) {
return 542;
}
- return 122 * (76 * Double.hashCode(x) + Double.hashCode(y));
+ return 122 * (76 * Double.hashCode(getX()) + Double.hashCode(getY()));
}
/** Test for the equality of two points.
@@ -126,7 +126,7 @@ public boolean equals(Object other) {
return this.isNaN();
}
- return (x == rhs.x) && (y == rhs.y);
+ return (getX() == rhs.getX()) && (getY() == rhs.getY());
}
return false;
}
@@ -134,7 +134,7 @@ public boolean equals(Object other) {
/** {@inheritDoc} */
@Override
public String toString() {
- return "(" + x + "; " + y + ")";
+ return "(" + getX() + "; " + getY() + ")";
}
/** Returns a point with the given coordinate values
@@ -151,7 +151,7 @@ public static Point2D of(double x, double y) {
* @return point instance
*/
public static Point2D of(Cartesian2D value) {
- return new Point2D(value.x, value.y);
+ return new Point2D(value.getX(), value.getY());
}
/** Returns a point with the coordinates from the given 2-element array.
@@ -185,7 +185,7 @@ public static Point2D of(double[] p) {
* @return point with coordinates calculated by {@code a * c}
*/
public static Point2D vectorCombination(double a, Cartesian2D c) {
- return new Point2D(a * c.x, a * c.y);
+ return new Point2D(a * c.getX(), a * c.getY());
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -210,8 +210,8 @@ public static Point2D vectorCombination(double a,
Cartesian2D c) {
*/
public static Point2D vectorCombination(double a1, Cartesian2D c1, double
a2, Cartesian2D c2) {
return new Point2D(
- LinearCombination.value(a1, c1.x, a2, c2.x),
- LinearCombination.value(a1, c1.y, a2, c2.y));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY()));
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -239,8 +239,8 @@ public static Point2D vectorCombination(double a1,
Cartesian2D c1, double a2, Ca
public static Point2D vectorCombination(double a1, Cartesian2D c1, double
a2, Cartesian2D c2,
double a3, Cartesian2D c3) {
return new Point2D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY()));
}
/** Returns a point with coordinates calculated by multiplying each input
coordinate
@@ -270,7 +270,7 @@ public static Point2D vectorCombination(double a1,
Cartesian2D c1, double a2, Ca
public static Point2D vectorCombination(double a1, Cartesian2D c1, double
a2, Cartesian2D c2,
double a3, Cartesian2D c3, double a4, Cartesian2D c4) {
return new Point2D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x, a4,
c4.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y, a4,
c4.y));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX(), a4, c4.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY(), a4, c4.getY()));
}
}
diff --git
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java
index 1a7e5bd..0bc84d2 100644
---
a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java
+++
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java
@@ -68,17 +68,16 @@ public Vector2D(double x, double y) {
/** Get the vector coordinates as a dimension 2 array.
* @return vector coordinates
- * @see #Cartesian2D(double[])
*/
@Override
public double[] toArray() {
- return new double[] { x, y };
+ return new double[] { getX(), getY() };
}
/** {@inheritDoc} */
@Override
public Point2D asPoint() {
- return new Point2D(x, y);
+ return new Point2D(getX(), getY());
}
/** {@inheritDoc} */
@@ -90,55 +89,59 @@ public Vector2D getZero() {
/** {@inheritDoc} */
@Override
public double getNorm1() {
- return Math.abs(x) + Math.abs(y);
+ return Math.abs(getX()) + Math.abs(getY());
}
/** {@inheritDoc} */
@Override
public double getNorm() {
+ final double x = getX();
+ final double y = getY();
return Math.sqrt ((x * x) + (y * y));
}
/** {@inheritDoc} */
@Override
public double getNormSq() {
+ final double x = getX();
+ final double y = getY();
return (x * x) + (y * y);
}
/** {@inheritDoc} */
@Override
public double getNormInf() {
- return Math.max(Math.abs(x), Math.abs(y));
+ return Math.max(Math.abs(getX()), Math.abs(getY()));
}
/** {@inheritDoc} */
@Override
public Vector2D add(Vector2D v) {
- return new Vector2D(x + v.x, y + v.y);
+ return new Vector2D(getX() + v.getX(), getY() + v.getY());
}
/** {@inheritDoc} */
@Override
public Vector2D add(double factor, Vector2D v) {
- return new Vector2D(x + (factor * v.x), y + (factor * v.y));
+ return new Vector2D(getX() + (factor * v.getX()), getY() + (factor *
v.getY()));
}
/** {@inheritDoc} */
@Override
public Vector2D subtract(Vector2D v) {
- return new Vector2D(x - v.x, y - v.y);
+ return new Vector2D(getX() - v.getX(), getY() - v.getY());
}
/** {@inheritDoc} */
@Override
public Vector2D subtract(double factor, Vector2D v) {
- return new Vector2D(x - (factor * v.x), y - (factor * v.y));
+ return new Vector2D(getX() - (factor * v.getX()), getY() - (factor *
v.getY()));
}
/** {@inheritDoc} */
@Override
public Vector2D negate() {
- return new Vector2D(-x, -y);
+ return new Vector2D(-getX(), -getY());
}
/** {@inheritDoc} */
@@ -154,14 +157,14 @@ public Vector2D normalize() throws IllegalStateException {
/** {@inheritDoc} */
@Override
public Vector2D scalarMultiply(double a) {
- return new Vector2D(a * x, a * y);
+ return new Vector2D(a * getX(), a * getY());
}
/** {@inheritDoc} */
@Override
public double distance1(Vector2D v) {
- double dx = Math.abs(x - v.x);
- double dy = Math.abs(y - v.y);
+ double dx = Math.abs(getX() - v.getX());
+ double dy = Math.abs(getY() - v.getY());
return dx + dy;
}
@@ -174,23 +177,23 @@ public double distance(Vector2D v) {
/** {@inheritDoc} */
@Override
public double distanceInf(Vector2D v) {
- double dx = Math.abs(x - v.x);
- double dy = Math.abs(y - v.y);
+ double dx = Math.abs(getX() - v.getX());
+ double dy = Math.abs(getY() - v.getY());
return Math.max(dx, dy);
}
/** {@inheritDoc} */
@Override
public double distanceSq(Vector2D v) {
- double dx = x - v.x;
- double dy = y - v.y;
+ double dx = getX() - v.getX();
+ double dy = getY() - v.getY();
return (dx * dx) + (dy * dy);
}
/** {@inheritDoc} */
@Override
public double dotProduct(Vector2D v) {
- return LinearCombination.value(x, v.x, y, v.y);
+ return LinearCombination.value(getX(), v.getX(), getY(), v.getY());
}
/** Compute the angular separation in radians between this vector
@@ -215,7 +218,7 @@ public double angle(Vector2D v) throws
IllegalArgumentException {
double threshold = normProduct * 0.9999;
if ((dot < -threshold) || (dot > threshold)) {
// the vectors are almost aligned, compute using the sine
- final double n = Math.abs(LinearCombination.value(x, v.y, -y,
v.x));
+ final double n = Math.abs(LinearCombination.value(getX(),
v.getY(), -getY(), v.getX()));
if (dot >= 0) {
return Math.asin(n / normProduct);
}
@@ -247,10 +250,10 @@ public double angle(Vector2D v) throws
IllegalArgumentException {
* @see <a href="http://mathworld.wolfram.com/CrossProduct.html";>Cross
product (Mathworld)</a>
*/
public double crossProduct(final Vector2D p1, final Vector2D p2) {
- final double x1 = p2.x - p1.x;
- final double y1 = y - p1.y;
- final double x2 = x - p1.x;
- final double y2 = p2.y - p1.y;
+ final double x1 = p2.getX() - p1.getX();
+ final double y1 = getY() - p1.getY();
+ final double x2 = getX() - p1.getX();
+ final double y2 = p2.getY() - p1.getY();
return LinearCombination.value(x1, y1, -x2, y2);
}
@@ -266,7 +269,7 @@ public int hashCode() {
if (isNaN()) {
return 542;
}
- return 122 * (76 * Double.hashCode(x) + Double.hashCode(y));
+ return 122 * (76 * Double.hashCode(getX()) + Double.hashCode(getY()));
}
/**
@@ -300,7 +303,7 @@ public boolean equals(Object other) {
return this.isNaN();
}
- return (x == rhs.x) && (y == rhs.y);
+ return (getX() == rhs.getX()) && (getY() == rhs.getY());
}
return false;
}
@@ -308,7 +311,7 @@ public boolean equals(Object other) {
/** {@inheritDoc} */
@Override
public String toString() {
- return "{" + x + "; " + y + "}";
+ return "{" + getX() + "; " + getY() + "}";
}
/** Computes the dot product between to vectors. This method simply
@@ -347,7 +350,7 @@ public static Vector2D of(double x, double y) {
* @return vector instance
*/
public static Vector2D of(Cartesian2D value) {
- return new Vector2D(value.x, value.y);
+ return new Vector2D(value.getX(), value.getY());
}
/** Creates a vector from the coordinates in the given 2-element array.
@@ -375,7 +378,7 @@ public static Vector2D of(double[] v) {
* @return vector with coordinates calculated by {@code a * c}
*/
public static Vector2D linearCombination(double a, Cartesian2D c) {
- return new Vector2D(a * c.x, a * c.y);
+ return new Vector2D(a * c.getX(), a * c.getY());
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -394,8 +397,8 @@ public static Vector2D linearCombination(double a,
Cartesian2D c) {
*/
public static Vector2D linearCombination(double a1, Cartesian2D c1, double
a2, Cartesian2D c2) {
return new Vector2D(
- LinearCombination.value(a1, c1.x, a2, c2.x),
- LinearCombination.value(a1, c1.y, a2, c2.y));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY()));
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -417,8 +420,8 @@ public static Vector2D linearCombination(double a1,
Cartesian2D c1, double a2, C
public static Vector2D linearCombination(double a1, Cartesian2D c1, double
a2, Cartesian2D c2,
double a3, Cartesian2D c3) {
return new Vector2D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY()));
}
/** Returns a vector consisting of the linear combination of the inputs.
@@ -442,7 +445,7 @@ public static Vector2D linearCombination(double a1,
Cartesian2D c1, double a2, C
public static Vector2D linearCombination(double a1, Cartesian2D c1, double
a2, Cartesian2D c2,
double a3, Cartesian2D c3, double a4, Cartesian2D c4) {
return new Vector2D(
- LinearCombination.value(a1, c1.x, a2, c2.x, a3, c3.x, a4,
c4.x),
- LinearCombination.value(a1, c1.y, a2, c2.y, a3, c3.y, a4,
c4.y));
+ LinearCombination.value(a1, c1.getX(), a2, c2.getX(), a3,
c3.getX(), a4, c4.getX()),
+ LinearCombination.value(a1, c1.getY(), a2, c2.getY(), a3,
c3.getY(), a4, c4.getY()));
}
}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
With regards,
Apache Git Services
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org
For additional commands, e-mail: dev-h...@commons.apache.org
