1   /* Copyright 2002-2025 CS GROUP
2    * Licensed to CS GROUP (CS) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * CS 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    *   http://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.orekit.estimation.measurements.gnss;
18  
19  import org.hipparchus.util.FastMath;
20  import org.junit.jupiter.api.Assertions;
21  import org.junit.jupiter.api.Test;
22  
23  public class AlternatingSamplerTest {
24  
25      @Test
26      public void testCanonicalA001057() {
27          check(new AlternatingSampler(0, 7.5),
28                0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7);
29      }
30  
31      @Test
32      public void testNegatedA001057() {
33          check(new AlternatingSampler(-0.1, 7.5),
34                0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5, -6, 6, -7, 7);
35      }
36  
37      @Test
38      public void testJavadocExample() {
39          check(new AlternatingSampler(17.3, 5.2),
40                17, 18, 16, 19, 15, 20, 14, 21, 13, 22);
41      }
42  
43      @Test
44      public void testIntegerLimitsOdd() {
45          check(new AlternatingSampler(12.0, 3.0),
46                12, 13, 11, 14, 10, 15, 9);
47      }
48  
49      @Test
50      public void testIntegerLimitsEven() {
51          check(new AlternatingSampler(12.0, 4.0),
52                12, 13, 11, 14, 10, 15, 9, 16, 8);
53      }
54  
55      @Test
56      public void testNoIntegerInRange() {
57          Assertions.assertFalse(new AlternatingSampler(12.4, 0.25).inRange());
58      }
59  
60      @Test
61      public void testLimits() {
62          for (double a = -5.5; a <= 5.5; a += 0.125) {
63                for (double r = 0.0; r <= 3.5; r += 0.125) {
64                    final AlternatingSampler sampler = new AlternatingSampler(a, r);
65  
66                    while (sampler.inRange()) {
67                        Assertions.assertTrue(sampler.getCurrent() >= a - r);
68                        Assertions.assertTrue(sampler.getCurrent() <= a + r);
69                        sampler.generateNext();
70                    };
71  
72                    // once range has been exceeded, all generated numbers
73                    // are out of range
74                    Assertions.assertFalse(sampler.inRange());
75                    sampler.generateNext();
76                    Assertions.assertFalse(sampler.inRange());
77                    sampler.generateNext();
78                    Assertions.assertFalse(sampler.inRange());
79                    sampler.generateNext();
80                    Assertions.assertFalse(sampler.inRange());
81  
82                }
83          }
84      }
85  
86      @Test
87      public void testNoMiss() {
88          for (double a = -5.5; a <= 5.5; a += 0.125) {
89                for (double r = 0.0; r <= 3.5; r += 0.125) {
90                    final int min = (int) FastMath.ceil(a - r);
91                    final int max = (int) FastMath.floor(a + r);
92                    final boolean[] seen = new boolean[max - min + 1];
93                    final AlternatingSampler sampler = new AlternatingSampler(a, r);
94  
95                    while (sampler.inRange()) {
96                        final int k = (int) (sampler.getCurrent() - min);
97                        Assertions.assertFalse(seen[k]);
98                        seen[k] = true;
99                        Assertions.assertTrue(sampler.getCurrent() >= a - r);
100                       Assertions.assertTrue(sampler.getCurrent() <= a + r);
101                       sampler.generateNext();
102                   };
103 
104                   // once range has been exceeded, all generated numbers
105                   // are out of range
106                   Assertions.assertFalse(sampler.inRange());
107                   sampler.generateNext();
108                   Assertions.assertFalse(sampler.inRange());
109                   sampler.generateNext();
110                   Assertions.assertFalse(sampler.inRange());
111                   sampler.generateNext();
112                   Assertions.assertFalse(sampler.inRange());
113 
114                   // all the integers in the [min; max] range
115                   // should have been generated exactly once
116                   for (final boolean s : seen) {
117                       Assertions.assertTrue(s);
118                   }
119 
120               }
121         }
122     }
123 
124     private void check(final AlternatingSampler sampler, final int... expected) {
125 
126         for (int i = 0; i < expected.length; ++i) {
127             Assertions.assertTrue(sampler.inRange());
128             Assertions.assertEquals(expected[i], sampler.getCurrent());
129             sampler.generateNext();
130         }
131 
132         // once range has been exceeded, all generated numbers
133         // are out of range
134         Assertions.assertFalse(sampler.inRange());
135         sampler.generateNext();
136         Assertions.assertFalse(sampler.inRange());
137         sampler.generateNext();
138         Assertions.assertFalse(sampler.inRange());
139         sampler.generateNext();
140         Assertions.assertFalse(sampler.inRange());
141 
142     }
143 
144 }
145