1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.orekit.forces.gravity.potential;
18
19
20 import org.hipparchus.util.FastMath;
21 import org.junit.Assert;
22 import org.junit.Test;
23 import org.orekit.errors.OrekitException;
24 import org.orekit.errors.OrekitMessages;
25
26 public class FlattenerTest {
27
28 @Test
29 public void testFullTriangle() {
30 final Flattener full = new Flattener(5, 5);
31 Assert.assertEquals(5, full.getDegree());
32 Assert.assertEquals(5, full.getOrder());
33 Assert.assertEquals(21, full.arraySize());
34 Assert.assertEquals( 0, full.index(5, 5));
35 Assert.assertEquals( 1, full.index(4, 4));
36 Assert.assertEquals( 2, full.index(5, 4));
37 Assert.assertEquals( 3, full.index(3, 3));
38 Assert.assertEquals( 4, full.index(4, 3));
39 Assert.assertEquals( 5, full.index(5, 3));
40 Assert.assertEquals( 6, full.index(2, 2));
41 Assert.assertEquals( 7, full.index(3, 2));
42 Assert.assertEquals( 8, full.index(4, 2));
43 Assert.assertEquals( 9, full.index(5, 2));
44 Assert.assertEquals(10, full.index(1, 1));
45 Assert.assertEquals(11, full.index(2, 1));
46 Assert.assertEquals(12, full.index(3, 1));
47 Assert.assertEquals(13, full.index(4, 1));
48 Assert.assertEquals(14, full.index(5, 1));
49 Assert.assertEquals(15, full.index(0, 0));
50 Assert.assertEquals(16, full.index(1, 0));
51 Assert.assertEquals(17, full.index(2, 0));
52 Assert.assertEquals(18, full.index(3, 0));
53 Assert.assertEquals(19, full.index(4, 0));
54 Assert.assertEquals(20, full.index(5, 0));
55 }
56
57 @Test
58 public void testTruncatedTriangle() {
59 final Flattener truncated = new Flattener(5, 3);
60 Assert.assertEquals(5, truncated.getDegree());
61 Assert.assertEquals(3, truncated.getOrder());
62 Assert.assertEquals(18, truncated.arraySize());
63 Assert.assertEquals( 0, truncated.index(3, 3));
64 Assert.assertEquals( 1, truncated.index(4, 3));
65 Assert.assertEquals( 2, truncated.index(5, 3));
66 Assert.assertEquals( 3, truncated.index(2, 2));
67 Assert.assertEquals( 4, truncated.index(3, 2));
68 Assert.assertEquals( 5, truncated.index(4, 2));
69 Assert.assertEquals( 6, truncated.index(5, 2));
70 Assert.assertEquals( 7, truncated.index(1, 1));
71 Assert.assertEquals( 8, truncated.index(2, 1));
72 Assert.assertEquals( 9, truncated.index(3, 1));
73 Assert.assertEquals(10, truncated.index(4, 1));
74 Assert.assertEquals(11, truncated.index(5, 1));
75 Assert.assertEquals(12, truncated.index(0, 0));
76 Assert.assertEquals(13, truncated.index(1, 0));
77 Assert.assertEquals(14, truncated.index(2, 0));
78 Assert.assertEquals(15, truncated.index(3, 0));
79 Assert.assertEquals(16, truncated.index(4, 0));
80 Assert.assertEquals(17, truncated.index(5, 0));
81 }
82
83 @Test
84 public void testFlatten() {
85 final Flattener flattener = new Flattener(5, 3);
86 double[][] triangular = {
87 { 12 },
88 { 13, 7 },
89 { 14, 8, 3 },
90 { 15, 9, 4, 0 },
91 { 16, 10, 5, 1 },
92 { 17, 11, 6, 2 }
93 };
94 final double[] flat = flattener.flatten(triangular);
95 for (int i = 0; i < flat.length; ++i) {
96 Assert.assertEquals(i, flat[i], 1.0e-15);
97 }
98 }
99
100 @Test
101 public void testSize() {
102 for (int degree = 0; degree <= 60; ++degree) {
103 for (int order = 0; order <= degree; ++order) {
104 Assert.assertEquals(loop(degree, order, degree, 0) + 1,
105 new Flattener(degree, order).arraySize());
106 }
107 }
108 }
109
110 @Test
111 public void testIndices() {
112 for (int degree = 0; degree <= 60; ++degree) {
113 for (int order = 0; order <= degree; ++order) {
114 final Flattener flattener = new Flattener(degree, order);
115 for (int n = 0; n <= degree; ++n) {
116 for (int m = 0; m <= FastMath.min(n, order); ++m) {
117 Assert.assertEquals(loop(degree, order, n, m),
118 flattener.index(n, m));
119 }
120 }
121 }
122 }
123 }
124
125 @Test
126 public void testLimits() {
127 for (int degree = 0; degree <= 20; ++degree) {
128 for (int order = 0; order <= degree; ++order) {
129 final Flattener flattener = new Flattener(degree, order);
130 Assert.assertEquals(degree, flattener.getDegree());
131 Assert.assertEquals(order, flattener.getOrder());
132 for (int n = -2; n < degree + 2; ++n) {
133 for (int m = -2; m <= FastMath.min(n, order) + 2; ++m) {
134 if (n < 0 || n > degree || m < 0 || m > FastMath.min(n, order)) {
135 try {
136 flattener.index(n, m);
137 Assert.fail("an exception should have been thrown");
138 } catch (OrekitException oe) {
139 Assert.assertEquals(OrekitMessages.WRONG_DEGREE_OR_ORDER, oe.getSpecifier());
140 Assert.assertEquals(n, ((Integer) oe.getParts()[0]).intValue());
141 Assert.assertEquals(m, ((Integer) oe.getParts()[1]).intValue());
142 Assert.assertEquals(degree, ((Integer) oe.getParts()[2]).intValue());
143 Assert.assertEquals(order, ((Integer) oe.getParts()[3]).intValue());
144 Assert.assertFalse(flattener.withinRange(n, m));
145 }
146 } else {
147 Assert.assertTrue(flattener.index(n, m) >= 0);
148 Assert.assertTrue(flattener.withinRange(n, m));
149 }
150 }
151 }
152 }
153 }
154 }
155
156 private int loop(final int degree, final int order, final int n, final int m) {
157 int count = 0;
158 for (int i = order; i > m; --i) {
159 for (int j = i; j <= degree; ++j) {
160 ++count;
161 }
162 }
163 for (int j = m; j <= n; ++j) {
164 ++count;
165 }
166 return count - 1;
167 }
168
169 }