1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 package org.hipparchus.geometry.euclidean.oned;
24
25 import org.hipparchus.exception.MathIllegalArgumentException;
26 import org.hipparchus.exception.MathRuntimeException;
27 import org.hipparchus.geometry.Space;
28 import org.hipparchus.geometry.euclidean.twod.FieldVector2D;
29 import org.hipparchus.util.Binary64Field;
30 import org.hipparchus.util.FastMath;
31 import org.hipparchus.util.Precision;
32 import org.junit.jupiter.api.Test;
33
34 import java.text.DecimalFormat;
35 import java.text.DecimalFormatSymbols;
36 import java.text.NumberFormat;
37 import java.util.Locale;
38
39 import static org.junit.jupiter.api.Assertions.assertEquals;
40 import static org.junit.jupiter.api.Assertions.assertFalse;
41 import static org.junit.jupiter.api.Assertions.assertNotEquals;
42 import static org.junit.jupiter.api.Assertions.assertTrue;
43 import static org.junit.jupiter.api.Assertions.fail;
44
45 class Vector1DTest {
46 @Test
47 void testConstructors() throws MathIllegalArgumentException {
48 checkVector(new Vector1D(3, new Vector1D(FastMath.PI / 3)),
49 FastMath.PI);
50 checkVector(new Vector1D(2, Vector1D.ONE, -3, new Vector1D(2)),
51 -4);
52 checkVector(new Vector1D(2, Vector1D.ONE,
53 5, new Vector1D(2),
54 -3, new Vector1D(3)),
55 3);
56 checkVector(new Vector1D(2, Vector1D.ONE,
57 5, new Vector1D(2),
58 5, new Vector1D(-2),
59 -3, new Vector1D(-3)),
60 11);
61 }
62
63 @Test
64 void testSpace() {
65 Space space = new Vector1D(1).getSpace();
66 assertEquals(1, space.getDimension());
67 }
68
69 @Test
70 void testZero() {
71 assertEquals(0, new Vector1D(1).getZero().getNorm(), 1.0e-15);
72 }
73
74 @SuppressWarnings("unlikely-arg-type")
75 @Test
76 void testEquals() {
77 Vector1D u1 = new Vector1D(1);
78 Vector1D u2 = new Vector1D(1);
79 assertEquals(u1, u1);
80 assertEquals(u1, u2);
81 assertNotEquals(u1, FieldVector2D.getPlusI(Binary64Field.getInstance()));
82 assertNotEquals(u1, new Vector1D(1 + 10 * Precision.EPSILON));
83 assertEquals(new Vector1D(Double.NaN), new Vector1D(Double.NaN));
84 assertEquals(Vector1D.NaN, Vector1D.NaN);
85 }
86
87 @Test
88 void testEqualsIeee754() {
89 Vector1D u1 = new Vector1D(1);
90 Vector1D u2 = new Vector1D(1);
91 assertTrue(u1.equalsIeee754(u1));
92 assertTrue(u1.equalsIeee754(u2));
93 assertFalse(u1.equalsIeee754(FieldVector2D.getPlusI(Binary64Field.getInstance())));
94 assertFalse(u1.equalsIeee754(new Vector1D(1 + 10 * Precision.EPSILON)));
95 assertFalse(new Vector1D(Double.NaN).equalsIeee754(new Vector1D(Double.NaN)));
96 assertFalse(Vector1D.NaN.equalsIeee754(Vector1D.NaN));
97 assertFalse(Vector1D.NaN.equalsIeee754(Vector1D.NaN));
98 }
99
100 @Test
101 void testHash() {
102 assertEquals(new Vector1D(Double.NaN).hashCode(), new Vector1D(Double.NaN).hashCode());
103 Vector1D u = new Vector1D(1);
104 Vector1D v = new Vector1D(1 + 10 * Precision.EPSILON);
105 assertTrue(u.hashCode() != v.hashCode());
106 }
107
108 @Test
109 void testInfinite() {
110 assertTrue(new Vector1D(Double.NEGATIVE_INFINITY).isInfinite());
111 assertTrue(new Vector1D(Double.POSITIVE_INFINITY).isInfinite());
112 assertFalse(new Vector1D(1).isInfinite());
113 assertFalse(new Vector1D(Double.NaN).isInfinite());
114 }
115
116 @Test
117 void testNaN() {
118 assertTrue(new Vector1D(Double.NaN).isNaN());
119 assertFalse(new Vector1D(1).isNaN());
120 assertFalse(new Vector1D(Double.NEGATIVE_INFINITY).isNaN());
121 }
122
123 @Test
124 void testToString() {
125 assertEquals("{3}", new Vector1D(3).toString());
126 NumberFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(Locale.US));
127 assertEquals("{3.000}", new Vector1D(3).toString(format));
128 }
129
130 @Test
131 void testCoordinates() {
132 Vector1D v = new Vector1D(1);
133 assertTrue(FastMath.abs(v.getX() - 1) < 1.0e-12);
134 }
135
136 @Test
137 void testNorm1() {
138 assertEquals(0.0, Vector1D.ZERO.getNorm1(), 0);
139 assertEquals(6.0, new Vector1D(6).getNorm1(), 0);
140 }
141
142 @Test
143 void testNorm() {
144 assertEquals(0.0, Vector1D.ZERO.getNorm(), 0);
145 assertEquals(3.0, new Vector1D(-3).getNorm(), 1.0e-12);
146 }
147
148 @Test
149 void testNormSq() {
150 assertEquals(0.0, new Vector1D(0).getNormSq(), 0);
151 assertEquals(9.0, new Vector1D(-3).getNormSq(), 1.0e-12);
152 }
153
154 @Test
155 void testNormInf() {
156 assertEquals(0.0, Vector1D.ZERO.getNormInf(), 0);
157 assertEquals(3.0, new Vector1D(-3).getNormInf(), 0);
158 }
159
160 @Test
161 void testDistance1() {
162 Vector1D v1 = new Vector1D(1);
163 Vector1D v2 = new Vector1D(-4);
164 assertEquals(0.0, new Vector1D(-1).distance1(new Vector1D(-1)), 0);
165 assertEquals(5.0, v1.distance1(v2), 1.0e-12);
166 assertEquals(v1.subtract(v2).getNorm1(), v1.distance1(v2), 1.0e-12);
167 }
168
169 @Test
170 void testDistance() {
171 Vector1D v1 = new Vector1D(1);
172 Vector1D v2 = new Vector1D(-4);
173 assertEquals(0.0, Vector1D.distance(new Vector1D(-1), new Vector1D(-1)), 0);
174 assertEquals(5.0, Vector1D.distance(v1, v2), 1.0e-12);
175 assertEquals(v1.subtract(v2).getNorm(), Vector1D.distance(v1, v2), 1.0e-12);
176 }
177
178 @Test
179 void testDistanceSq() {
180 Vector1D v1 = new Vector1D(1);
181 Vector1D v2 = new Vector1D(-4);
182 assertEquals(0.0, Vector1D.distanceSq(new Vector1D(-1), new Vector1D(-1)), 0);
183 assertEquals(25.0, Vector1D.distanceSq(v1, v2), 1.0e-12);
184 assertEquals(Vector1D.distance(v1, v2) * Vector1D.distance(v1, v2),
185 Vector1D.distanceSq(v1, v2), 1.0e-12);
186 }
187
188 @Test
189 void testDistanceInf() {
190 Vector1D v1 = new Vector1D(1);
191 Vector1D v2 = new Vector1D(-4);
192 assertEquals(0.0, Vector1D.distanceInf(new Vector1D(-1), new Vector1D(-1)), 0);
193 assertEquals(5.0, Vector1D.distanceInf(v1, v2), 1.0e-12);
194 assertEquals(v1.subtract(v2).getNormInf(), Vector1D.distanceInf(v1, v2), 1.0e-12);
195 }
196
197 @Test
198 void testSubtract() {
199 Vector1D v1 = new Vector1D(1);
200 Vector1D v2 = new Vector1D(-3);
201 v1 = v1.subtract(v2);
202 checkVector(v1, 4);
203
204 checkVector(v2.subtract(v1), -7);
205 checkVector(v2.subtract(3, v1), -15);
206 }
207
208 @Test
209 void testAdd() {
210 Vector1D v1 = new Vector1D(1);
211 Vector1D v2 = new Vector1D(-3);
212 v1 = v1.add(v2);
213 checkVector(v1, -2);
214
215 checkVector(v2.add(v1), -5);
216 checkVector(v2.add(3, v1), -9);
217 }
218
219 @Test
220 void testScalarProduct() {
221 Vector1D v = new Vector1D(1);
222 v = v.scalarMultiply(3);
223 checkVector(v, 3);
224
225 checkVector(v.scalarMultiply(0.5), 1.5);
226 }
227
228 @Test
229 void testNormalize() throws MathRuntimeException {
230 assertEquals(1.0, new Vector1D(5).normalize().getNorm(), 1.0e-12);
231 try {
232 Vector1D.ZERO.normalize();
233 fail("an exception should have been thrown");
234 } catch (MathRuntimeException ae) {
235
236 }
237 }
238
239 @Test
240 void testNegate() {
241 checkVector(new Vector1D(0.1).negate(), -0.1);
242 }
243
244 @Test
245 void testArithmeticBlending() {
246
247
248 final Vector1D v1 = new Vector1D(1);
249 final Vector1D v2 = new Vector1D(2);
250
251 final double blendingValue = 0.7;
252
253
254 final Vector1D blendedVector = v1.blendArithmeticallyWith(v2, blendingValue);
255
256
257 checkVector(blendedVector, 1.7);
258 }
259
260 @Test
261 void testMoveTowards() {
262 checkVector(new Vector1D(5.0).moveTowards(new Vector1D(3.0), 0.0), 5.0);
263 checkVector(new Vector1D(5.0).moveTowards(new Vector1D(3.0), 0.5), 4.0);
264 checkVector(new Vector1D(5.0).moveTowards(new Vector1D(3.0), 1.0), 3.0);
265 }
266
267 private void checkVector(Vector1D v, double x) {
268 assertEquals(x, v.getX(), 1.0e-12);
269 }
270
271 }