View Javadoc
1   /*
2    * Licensed to the Hipparchus project under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The Hipparchus project licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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 FieldTupleTest extends CalculusFieldElementAbstractTest<FieldTuple<Binary64>> {
27      public static final Binary64 X = new Binary64(1.2345);
28  
29      public static final FieldTuple<Binary64> PLUS_X = new FieldTuple<Binary64>(X, X);
30  
31      public static final FieldTuple<Binary64> MINUS_X = new FieldTuple<Binary64>(X.negate(), X.negate());
32  
33      public static final Binary64 Y = new Binary64(6.789);
34  
35      public static final FieldTuple<Binary64> PLUS_Y = new FieldTuple<Binary64>(Y, Y);
36  
37      public static final FieldTuple<Binary64> MINUS_Y = new FieldTuple<Binary64>(Y.negate(), Y.negate());
38  
39      public static final FieldTuple<Binary64> PLUS_ZERO = new FieldTuple<Binary64>(new Binary64(0.0), new Binary64(0.0));
40  
41      public static final FieldTuple<Binary64> MINUS_ZERO = new FieldTuple<Binary64>(new Binary64(-0.0), new Binary64(-0.0));
42  
43      @Override
44      protected FieldTuple<Binary64> build(final double x) {
45          return new FieldTuple<Binary64>(new Binary64(x), new Binary64(x));
46      }
47  
48      @Test
49      void testComponents() {
50          assertEquals(2, PLUS_ZERO.getDimension());
51          final FieldTuple<Binary64> oneToFive = new FieldTuple<Binary64>(new Binary64(1),
52                                                                            new Binary64(2),
53                                                                            new Binary64(3),
54                                                                            new Binary64(4),
55                                                                            new Binary64(5));
56          assertEquals(5, oneToFive.getDimension());
57          assertArrayEquals(new Binary64[] {
58              new Binary64(1), new Binary64(2), new Binary64(3), new Binary64(4), new Binary64(5) },
59                                   oneToFive.getComponents());
60          assertEquals(1, oneToFive.getComponent(0).getReal(), 1.0e-10);
61          assertEquals(2, oneToFive.getComponent(1).getReal(), 1.0e-10);
62          assertEquals(3, oneToFive.getComponent(2).getReal(), 1.0e-10);
63          assertEquals(4, oneToFive.getComponent(3).getReal(), 1.0e-10);
64          assertEquals(5, oneToFive.getComponent(4).getReal(), 1.0e-10);
65      }
66  
67      @Test
68      void testEquals() {
69          assertNotEquals(PLUS_ZERO, null);
70          assertEquals(PLUS_ZERO, PLUS_ZERO);
71          assertEquals(PLUS_X,    PLUS_X);
72          assertEquals(PLUS_Y,    PLUS_Y);
73          assertEquals(MINUS_X,   MINUS_X);
74          assertEquals(MINUS_Y,   MINUS_Y);
75          assertNotEquals(PLUS_X,  new FieldTuple<>(new Binary64(1),
76                                                           new Binary64(2),
77                                                           new Binary64(3),
78                                                           new Binary64(4),
79                                                           new Binary64(5)));
80          assertNotEquals(PLUS_X,  new FieldTuple<>(PLUS_X.getComponent(0), new Binary64(999.999)));
81          assertNotEquals(null, PLUS_ZERO.getField());
82          assertNotEquals(PLUS_X.getField(),  new FieldTuple<>(new Binary64(1),
83                          new Binary64(2),
84                          new Binary64(3),
85                          new Binary64(4),
86                          new Binary64(5)).getField());
87          assertEquals(PLUS_ZERO.getField(), MINUS_Y.getField());
88      }
89  
90      @Test
91      void testHashcode() {
92          assertEquals(-1264241693, PLUS_ZERO.getField().hashCode());
93          assertEquals(1492525478, PLUS_ZERO.hashCode());
94          assertEquals(1492525478, MINUS_ZERO.hashCode());
95          assertEquals(211878758, PLUS_X.hashCode());
96          assertEquals(211878758, MINUS_X.hashCode());
97          assertEquals(1460019622, new FieldTuple<>(new Binary64(1), new Binary64(2)).hashCode());
98          assertEquals(1491476902, new FieldTuple<>(new Binary64(2), new Binary64(1)).hashCode());
99      }
100 
101     @Test
102     void testAdd() {
103         FieldTuple<Binary64> expected, actual;
104 
105         expected = new FieldTuple<Binary64>(X.add(Y), X.add(Y));
106         actual = PLUS_X.add(PLUS_Y);
107         assertEquals(expected, actual);
108         actual = PLUS_Y.add(PLUS_X);
109         assertEquals(expected, actual);
110 
111         expected = new FieldTuple<Binary64>(X.add(Y.negate()), X.add(Y.negate()));
112         actual = PLUS_X.add(MINUS_Y);
113         assertEquals(expected, actual);
114         actual = MINUS_Y.add(PLUS_X);
115         assertEquals(expected, actual);
116 
117         expected = new FieldTuple<Binary64>(X.negate().add(Y.negate()), X.negate().add(Y.negate()));
118         actual = MINUS_X.add(MINUS_Y);
119         assertEquals(expected, actual);
120         actual = MINUS_Y.add(MINUS_X);
121         assertEquals(expected, actual);
122 
123     }
124 
125     @Test
126     void testSubtract() {
127         FieldTuple<Binary64> expected, actual;
128 
129         expected = new FieldTuple<Binary64>(X.subtract(Y), X.subtract(Y));
130         actual = PLUS_X.subtract(PLUS_Y);
131         assertEquals(expected, actual);
132 
133         expected = new FieldTuple<Binary64>(X.subtract(Y.negate()), X.subtract(Y.negate()));
134         actual = PLUS_X.subtract(MINUS_Y);
135         assertEquals(expected, actual);
136 
137         expected = new FieldTuple<Binary64>(X.negate().subtract(Y), X.negate().subtract(Y));
138         actual = MINUS_X.subtract(PLUS_Y);
139         assertEquals(expected, actual);
140 
141         expected = new FieldTuple<Binary64>(X.negate().subtract(Y.negate()), X.negate().subtract(Y.negate()));
142         actual = MINUS_X.subtract(MINUS_Y);
143         assertEquals(expected, actual);
144 
145     }
146 
147     @Test
148     void testNegate() {
149         FieldTuple<Binary64> expected, actual;
150 
151         expected = MINUS_X;
152         actual = PLUS_X.negate();
153         assertEquals(expected, actual);
154 
155         expected = PLUS_X;
156         actual = MINUS_X.negate();
157         assertEquals(expected, actual);
158 
159         expected = MINUS_ZERO;
160         actual = PLUS_ZERO.negate();
161         assertEquals(expected, actual);
162 
163         expected = PLUS_ZERO;
164         actual = MINUS_ZERO.negate();
165         assertEquals(expected, actual);
166 
167     }
168 
169     @Test
170     void testMultiply() {
171         FieldTuple<Binary64> expected, actual;
172 
173         expected = new FieldTuple<Binary64>(X.multiply(Y), X.multiply(Y));
174         actual = PLUS_X.multiply(PLUS_Y);
175         assertEquals(expected, actual);
176         actual = PLUS_Y.multiply(PLUS_X);
177         assertEquals(expected, actual);
178 
179         expected = new FieldTuple<Binary64>(X.multiply(Y.negate()), X.multiply(Y.negate()));
180         actual = PLUS_X.multiply(MINUS_Y);
181         assertEquals(expected, actual);
182         actual = MINUS_Y.multiply(PLUS_X);
183         assertEquals(expected, actual);
184 
185         expected = new FieldTuple<Binary64>(X.negate().multiply(Y.negate()), X.negate().multiply(Y.negate()));
186         actual = MINUS_X.multiply(MINUS_Y);
187         assertEquals(expected, actual);
188         actual = MINUS_Y.multiply(MINUS_X);
189         assertEquals(expected, actual);
190 
191     }
192 
193     @Test
194     void testDivide() {
195         FieldTuple<Binary64> expected, actual;
196 
197         expected = new FieldTuple<Binary64>(X.divide(Y), X.divide(Y));
198         actual = PLUS_X.divide(PLUS_Y);
199         assertEquals(expected, actual);
200 
201         expected = new FieldTuple<Binary64>(X.divide(Y.negate()), X.divide(Y.negate()));
202         actual = PLUS_X.divide(MINUS_Y);
203         assertEquals(expected, actual);
204 
205         expected = new FieldTuple<Binary64>(X.negate().divide(Y), X.negate().divide(Y));
206         actual = MINUS_X.divide(PLUS_Y);
207         assertEquals(expected, actual);
208 
209         expected = new FieldTuple<Binary64>(X.negate().divide(Y.negate()), X.negate().divide(Y.negate()));
210         actual = MINUS_X.divide(MINUS_Y);
211         assertEquals(expected, actual);
212 
213     }
214 
215     @Test
216     void testReciprocal() {
217         FieldTuple<Binary64> expected, actual;
218 
219         expected = new FieldTuple<Binary64>(X.reciprocal(), X.reciprocal());
220         actual = PLUS_X.reciprocal();
221         assertEquals(expected, actual);
222 
223         expected = new FieldTuple<Binary64>(X.negate().reciprocal(), X.negate().reciprocal());
224         actual = MINUS_X.reciprocal();
225         assertEquals(expected, actual);
226 
227         expected = PLUS_ZERO;
228         actual = new FieldTuple<Binary64>(new Binary64(Double.POSITIVE_INFINITY), new Binary64(Double.POSITIVE_INFINITY)).reciprocal();
229         assertEquals(expected, actual);
230 
231         expected = MINUS_ZERO;
232         actual = new FieldTuple<Binary64>(new Binary64(Double.NEGATIVE_INFINITY), new Binary64(Double.NEGATIVE_INFINITY)).reciprocal();
233         assertEquals(expected, actual);
234     }
235 
236     @Test
237     void testToDegreesDefinition() {
238         double epsilon = 3.0e-16;
239         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
240             for (double x = 0.1; x < 1.2; x += 0.001) {
241                 final Binary64 dec64 = new Binary64(x);
242                 FieldTuple<Binary64> value = new FieldTuple<Binary64>(dec64, dec64);
243                 assertEquals(FastMath.toDegrees(x), value.toDegrees().getReal(), epsilon);
244             }
245         }
246     }
247 
248     @Test
249     void testToRadiansDefinition() {
250         double epsilon = 3.0e-16;
251         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
252             for (double x = 0.1; x < 1.2; x += 0.001) {
253                 final Binary64 dec64 = new Binary64(x);
254                 FieldTuple<Binary64> value = new FieldTuple<Binary64>(dec64, dec64);
255                 assertEquals(FastMath.toRadians(x), value.toRadians().getReal(), epsilon);
256             }
257         }
258     }
259 
260     @Test
261     void testDegRad() {
262         for (double x = 0.1; x < 1.2; x += 0.001) {
263             final Binary64 dec64 = new Binary64(x);
264             FieldTuple<Binary64> value = new FieldTuple<Binary64>(dec64, dec64);
265             FieldTuple<Binary64> rebuilt = value.toDegrees().toRadians();
266             FieldTuple<Binary64> zero = rebuilt.subtract(value);
267             assertEquals(0, zero.getReal(), 3.0e-16);
268         }
269     }
270 
271 }