1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.hipparchus.util;
18
19 import org.hipparchus.CalculusFieldElementAbstractTest;
20 import org.junit.jupiter.api.Test;
21
22 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
23 import static org.junit.jupiter.api.Assertions.assertEquals;
24 import static org.junit.jupiter.api.Assertions.assertNotEquals;
25
26 public class TupleTest extends CalculusFieldElementAbstractTest<Tuple> {
27 public static final double X = 1.2345;
28
29 public static final Tuple PLUS_X = new Tuple(X, X);
30
31 public static final Tuple MINUS_X = new Tuple(-X, -X);
32
33 public static final double Y = 6.789;
34
35 public static final Tuple PLUS_Y = new Tuple(Y, Y);
36
37 public static final Tuple MINUS_Y = new Tuple(-Y, -Y);
38
39 public static final Tuple PLUS_ZERO = new Tuple(0.0, 0.0);
40
41 public static final Tuple MINUS_ZERO = new Tuple(-0.0, -0.0);
42
43 @Override
44 protected Tuple build(final double x) {
45 return new Tuple(x, x);
46 }
47
48 @Test
49 void testComponents() {
50 assertEquals(2, PLUS_ZERO.getDimension());
51 final Tuple oneToFive = new Tuple(1, 2, 3, 4, 5);
52 assertEquals(5, oneToFive.getDimension());
53 assertArrayEquals(new double[] { 1, 2, 3, 4, 5 }, oneToFive.getComponents(), 1.0e-10);
54 assertEquals(1, oneToFive.getComponent(0), 1.0e-10);
55 assertEquals(2, oneToFive.getComponent(1), 1.0e-10);
56 assertEquals(3, oneToFive.getComponent(2), 1.0e-10);
57 assertEquals(4, oneToFive.getComponent(3), 1.0e-10);
58 assertEquals(5, oneToFive.getComponent(4), 1.0e-10);
59 }
60
61 @Test
62 void testEquals() {
63 assertNotEquals(PLUS_ZERO, null);
64 assertEquals(PLUS_ZERO, PLUS_ZERO);
65 assertEquals(PLUS_X, PLUS_X);
66 assertEquals(PLUS_Y, PLUS_Y);
67 assertEquals(MINUS_X, MINUS_X);
68 assertEquals(MINUS_Y, MINUS_Y);
69 assertNotEquals(PLUS_X, new Tuple(1, 2, 3, 4, 5));
70 assertNotEquals(PLUS_X, new Tuple(PLUS_X.getComponent(0), 999.999));
71 assertNotEquals(null, PLUS_ZERO.getField());
72 assertNotEquals(PLUS_X.getField(), new Tuple(1, 2, 3, 4, 5).getField());
73 assertEquals(PLUS_ZERO.getField(), MINUS_Y.getField());
74 }
75
76 @Test
77 void testHashcode() {
78 assertEquals(1718765887, PLUS_ZERO.getField().hashCode());
79 assertEquals(884058117, PLUS_ZERO.hashCode());
80 assertEquals(884058117, MINUS_ZERO.hashCode());
81 assertEquals(-396588603, PLUS_X.hashCode());
82 assertEquals(-396588603, MINUS_X.hashCode());
83 assertEquals(851552261, new Tuple(1, 2).hashCode());
84 assertEquals(883009541, new Tuple(2, 1).hashCode());
85 }
86
87 @Test
88 void testAdd() {
89 Tuple expected, actual;
90
91 expected = new Tuple(X + Y, X + Y);
92 actual = PLUS_X.add(PLUS_Y);
93 assertEquals(expected, actual);
94 actual = PLUS_Y.add(PLUS_X);
95 assertEquals(expected, actual);
96
97 expected = new Tuple(X + (-Y), X + (-Y));
98 actual = PLUS_X.add(MINUS_Y);
99 assertEquals(expected, actual);
100 actual = MINUS_Y.add(PLUS_X);
101 assertEquals(expected, actual);
102
103 expected = new Tuple((-X) + (-Y), (-X) + (-Y));
104 actual = MINUS_X.add(MINUS_Y);
105 assertEquals(expected, actual);
106 actual = MINUS_Y.add(MINUS_X);
107 assertEquals(expected, actual);
108
109 }
110
111 @Test
112 void testSubtract() {
113 Tuple expected, actual;
114
115 expected = new Tuple(X - Y, X - Y);
116 actual = PLUS_X.subtract(PLUS_Y);
117 assertEquals(expected, actual);
118
119 expected = new Tuple(X - (-Y), X - (-Y));
120 actual = PLUS_X.subtract(MINUS_Y);
121 assertEquals(expected, actual);
122
123 expected = new Tuple((-X) - Y, (-X) - Y);
124 actual = MINUS_X.subtract(PLUS_Y);
125 assertEquals(expected, actual);
126
127 expected = new Tuple((-X) - (-Y), (-X) - (-Y));
128 actual = MINUS_X.subtract(MINUS_Y);
129 assertEquals(expected, actual);
130
131 }
132
133 @Test
134 void testNegate() {
135 Tuple expected, actual;
136
137 expected = MINUS_X;
138 actual = PLUS_X.negate();
139 assertEquals(expected, actual);
140
141 expected = PLUS_X;
142 actual = MINUS_X.negate();
143 assertEquals(expected, actual);
144
145 expected = MINUS_ZERO;
146 actual = PLUS_ZERO.negate();
147 assertEquals(expected, actual);
148
149 expected = PLUS_ZERO;
150 actual = MINUS_ZERO.negate();
151 assertEquals(expected, actual);
152
153 }
154
155 @Test
156 void testMultiply() {
157 Tuple expected, actual;
158
159 expected = new Tuple(X * Y, X * Y);
160 actual = PLUS_X.multiply(PLUS_Y);
161 assertEquals(expected, actual);
162 actual = PLUS_Y.multiply(PLUS_X);
163 assertEquals(expected, actual);
164
165 expected = new Tuple(X * (-Y), X * (-Y));
166 actual = PLUS_X.multiply(MINUS_Y);
167 assertEquals(expected, actual);
168 actual = MINUS_Y.multiply(PLUS_X);
169 assertEquals(expected, actual);
170
171 expected = new Tuple((-X) * (-Y), (-X) * (-Y));
172 actual = MINUS_X.multiply(MINUS_Y);
173 assertEquals(expected, actual);
174 actual = MINUS_Y.multiply(MINUS_X);
175 assertEquals(expected, actual);
176
177 }
178
179 @Test
180 void testDivide() {
181 Tuple expected, actual;
182
183 expected = new Tuple(X / Y, X / Y);
184 actual = PLUS_X.divide(PLUS_Y);
185 assertEquals(expected, actual);
186
187 expected = new Tuple(X / (-Y), X / (-Y));
188 actual = PLUS_X.divide(MINUS_Y);
189 assertEquals(expected, actual);
190
191 expected = new Tuple((-X) / Y, (-X) / Y);
192 actual = MINUS_X.divide(PLUS_Y);
193 assertEquals(expected, actual);
194
195 expected = new Tuple((-X) / (-Y), (-X) / (-Y));
196 actual = MINUS_X.divide(MINUS_Y);
197 assertEquals(expected, actual);
198
199 }
200
201 @Test
202 void testReciprocal() {
203 Tuple expected, actual;
204
205 expected = new Tuple(1.0 / X, 1.0 / X);
206 actual = PLUS_X.reciprocal();
207 assertEquals(expected, actual);
208
209 expected = new Tuple(1.0 / (-X), 1.0 / (-X));
210 actual = MINUS_X.reciprocal();
211 assertEquals(expected, actual);
212
213 expected = PLUS_ZERO;
214 actual = new Tuple(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY).reciprocal();
215 assertEquals(expected, actual);
216
217 expected = MINUS_ZERO;
218 actual = new Tuple(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY).reciprocal();
219 assertEquals(expected, actual);
220 }
221
222 @Test
223 void testToDegreesDefinition() {
224 double epsilon = 3.0e-16;
225 for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
226 for (double x = 0.1; x < 1.2; x += 0.001) {
227 Tuple value = new Tuple(x, x);
228 assertEquals(FastMath.toDegrees(x), value.toDegrees().getReal(), epsilon);
229 }
230 }
231 }
232
233 @Test
234 void testToRadiansDefinition() {
235 double epsilon = 3.0e-16;
236 for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
237 for (double x = 0.1; x < 1.2; x += 0.001) {
238 Tuple value = new Tuple(x, x);
239 assertEquals(FastMath.toRadians(x), value.toRadians().getReal(), epsilon);
240 }
241 }
242 }
243
244 @Test
245 void testDegRad() {
246 for (double x = 0.1; x < 1.2; x += 0.001) {
247 Tuple value = new Tuple(x, x);
248 Tuple rebuilt = value.toDegrees().toRadians();
249 Tuple zero = rebuilt.subtract(value);
250 assertEquals(0, zero.getReal(), 3.0e-16);
251 }
252 }
253
254 }