Debian Codegraph @

sourceTest/java/ch/systemsx/cisd/base/mdarray/MDArrayTests.java

raw
1 /*
2 * Copyright 2007 - 2018 ETH Zuerich, CISD and SIS.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package ch.systemsx.cisd.base.mdarray;
18
19 import static org.testng.Assert.assertNotSame;
20 import static org.testng.AssertJUnit.assertEquals;
21 import static org.testng.AssertJUnit.assertTrue;
22
23 import java.lang.reflect.InvocationTargetException;
24 import java.lang.reflect.Method;
25 import java.util.Arrays;
26
27 import org.testng.annotations.Test;
28
29 import ch.systemsx.cisd.base.BuildAndEnvironmentInfo;
30
31 /**
32 * Test cases for {@link MDAbstractArray}.
33 *
34 * @author Bernd Rinn
35 */
36 public class MDArrayTests
37 {
38 @Test
39 public void testGetLength()
40 {
41 assertEquals(0, MDAbstractArray.getLength(new int[]
42 { 0 }, 0));
43 assertEquals(1, MDAbstractArray.getLength(new int[]
44 { 1 }, 0));
45 assertEquals(2, MDAbstractArray.getLength(new int[]
46 { 1 }, 2));
47 assertEquals(15, MDAbstractArray.getLength(new int[]
48 { 5, 3 }, 0));
49 assertEquals(21, MDAbstractArray.getLength(new int[]
50 { 5, 3 }, 7));
51 assertEquals(15, MDAbstractArray.getLength(new int[]
52 { 5, 3 }, 3));
53 assertEquals(1, MDAbstractArray.getLength(new int[]
54 { 1, 1, 1 }, 0));
55 assertEquals(3, MDAbstractArray.getLength(new int[]
56 { 1, 1, 1 }, 3));
57 assertEquals(8, MDAbstractArray.getLength(new int[]
58 { 2, 2, 2 }, 0));
59 assertEquals(20, MDAbstractArray.getLength(new int[]
60 { 2, 2, 2 }, 5));
61 assertEquals(2, MDAbstractArray.getLength(new int[]
62 { 1, 1, 2 }, 0));
63 assertEquals(2, MDAbstractArray.getLength(new int[]
64 { 1, 2, 1 }, 0));
65 assertEquals(2, MDAbstractArray.getLength(new int[]
66 { 2, 1, 1 }, 0));
67 assertEquals(50, MDAbstractArray.getLength(new int[]
68 { 10, 1, 5 }, 0));
69 assertEquals(50, MDAbstractArray.getLength(new long[]
70 { 10, 1, 5 }, 0));
71 }
72
73 @Test
74 public void testToInt()
75 {
76 assertTrue(Arrays.equals(new int[]
77 { 1, 2, 3 }, MDAbstractArray.toInt(new long[]
78 { 1, 2, 3 })));
79 assertTrue(Arrays.equals(new int[] {}, MDAbstractArray.toInt(new long[] {})));
80 }
81
82 @Test
83 public void testComputeIndex()
84 {
85 MDArray<Object> array;
86 array = new MDArray<Object>(Object.class, new int[]
87 { 33 });
88 assertEquals(17, array.computeIndex(new int[]
89 { 17 }));
90 assertTrue(Arrays.toString(array.computeReverseIndex(17)), Arrays.equals(new int[]
91 { 17 }, array.computeReverseIndex(17)));
92 array = new MDArray<Object>(Object.class, new int[]
93 { 100, 10 });
94 assertEquals(10 * 42 + 8, array.computeIndex(new int[]
95 { 42, 8 }));
96 assertTrue(Arrays.toString(array.computeReverseIndex(10 * 42 + 8)),
97 Arrays.equals(new int[]
98 { 42, 8 }, array.computeReverseIndex(10 * 42 + 8)));
99 array = new MDArray<Object>(Object.class, new int[]
100 { 2, 7, 3 });
101 assertEquals(3 * 7 * 1 + 3 * 3 + 2, array.computeIndex(new int[]
102 { 1, 3, 2 }));
103 assertTrue(Arrays.toString(array.computeReverseIndex(3 * 7 * 1 + 3 * 3 + 2)),
104 Arrays.equals(new int[]
105 { 1, 3, 2 }, array.computeReverseIndex(3 * 7 * 1 + 3 * 3 + 2)));
106 }
107
108 @Test
109 public void testComputeIndex2D()
110 {
111 MDArray<Object> array;
112 array = new MDArray<Object>(Object.class, new int[]
113 { 100, 10 });
114 assertEquals(array.computeIndex(new int[]
115 { 5, 8, }), array.computeIndex(5, 8));
116 assertEquals(array.computeIndex(new int[]
117 { 9, 1, }), array.computeIndex(9, 1));
118 array = new MDArray<Object>(Object.class, new int[]
119 { 101, 11 });
120 assertEquals(array.computeIndex(new int[]
121 { 5, 8, }), array.computeIndex(5, 8));
122 assertEquals(array.computeIndex(new int[]
123 { 9, 1, }), array.computeIndex(9, 1));
124 }
125
126 @Test
127 public void testComputeIndex3()
128 {
129 MDArray<Object> array;
130 array = new MDArray<Object>(Object.class, new int[]
131 { 100, 10, 17 });
132 assertEquals(array.computeIndex(new int[]
133 { 5, 8, 16 }), array.computeIndex(5, 8, 16));
134 assertEquals(array.computeIndex(new int[]
135 { 9, 1, 5 }), array.computeIndex(9, 1, 5));
136 array = new MDArray<Object>(Object.class, new int[]
137 { 101, 11, 3 });
138 assertEquals(array.computeIndex(new int[]
139 { 5, 8, 0 }), array.computeIndex(5, 8, 0));
140 assertEquals(array.computeIndex(new int[]
141 { 9, 1, 2 }), array.computeIndex(9, 1, 2));
142 }
143
144 @Test
145 public void testEmptyMatrix()
146 {
147 final MDFloatArray arr = new MDFloatArray(new float[0][0]);
148 assertEquals(0, arr.dimensions()[0]);
149 assertEquals(0, arr.dimensions()[1]);
150 }
151
152 @Test
153 public void testChangeHyperRowCountIntArray()
154 {
155 final MDIntArray arr = new MDIntArray(new int[]
156 { 2, 2 }, 3);
157 assertEquals(2, arr.dimensions[0]);
158 assertEquals(2, arr.dimensions[1]);
159 arr.set(1, 0, 0);
160 arr.set(2, 0, 1);
161 arr.set(3, 1, 0);
162 arr.set(4, 1, 1);
163
164 final MDIntArray arr2 = new MDIntArray(arr.getCopyAsFlatArray(), arr.dimensions());
165 assertTrue(arr2.equals(arr));
166
167 arr.incNumberOfHyperRows(1);
168 assertEquals(3, arr.dimensions[0]);
169 assertEquals(1, arr.get(0, 0));
170 assertEquals(2, arr.get(0, 1));
171 assertEquals(3, arr.get(1, 0));
172 assertEquals(4, arr.get(1, 1));
173 arr.set(5, 2, 0);
174 arr.set(6, 2, 1);
175 arr.incNumberOfHyperRows(2);
176 assertEquals(5, arr.dimensions[0]);
177 assertEquals(1, arr.get(0, 0));
178 assertEquals(2, arr.get(0, 1));
179 assertEquals(3, arr.get(1, 0));
180 assertEquals(4, arr.get(1, 1));
181 assertEquals(5, arr.get(2, 0));
182 assertEquals(6, arr.get(2, 1));
183 arr.set(7, 3, 0);
184 arr.set(8, 3, 1);
185 arr.decNumberOfHyperRows(1);
186 assertEquals(4, arr.dimensions[0]);
187 assertEquals(1, arr.get(0, 0));
188 assertEquals(2, arr.get(0, 1));
189 assertEquals(3, arr.get(1, 0));
190 assertEquals(4, arr.get(1, 1));
191 assertEquals(5, arr.get(2, 0));
192 assertEquals(6, arr.get(2, 1));
193 assertEquals(7, arr.get(3, 0));
194 assertEquals(8, arr.get(3, 1));
195 }
196
197 @Test
198 public void testChangeHyperRowCountIntArrayFromZero()
199 {
200 final MDIntArray arr = new MDIntArray(new int[]
201 { 0 });
202 assertEquals(0, arr.size(0));
203 arr.incNumberOfHyperRows(1);
204 assertEquals(1, arr.size(0));
205 arr.set(17, 0);
206 assertEquals(17, arr.get(0));
207 arr.incNumberOfHyperRows(1);
208 arr.incNumberOfHyperRows(1);
209 assertEquals(3, arr.size());
210 }
211
212 @Test
213 public void testChangeHyperRowCountTArray()
214 {
215 final MDArray<Integer> arr = new MDArray<Integer>(Integer.class, new int[]
216 { 2, 2 }, 3);
217 assertEquals(2, arr.dimensions[0]);
218 assertEquals(2, arr.dimensions[1]);
219 arr.set(1, 0, 0);
220 arr.set(2, 0, 1);
221 arr.set(3, 1, 0);
222 arr.set(4, 1, 1);
223 arr.incNumberOfHyperRows(1);
224 assertEquals(3, arr.dimensions[0]);
225 assertEquals(1, (int) arr.get(0, 0));
226 assertEquals(2, (int) arr.get(0, 1));
227 assertEquals(3, (int) arr.get(1, 0));
228 assertEquals(4, (int) arr.get(1, 1));
229 arr.set(5, 2, 0);
230 arr.set(6, 2, 1);
231 arr.incNumberOfHyperRows(2);
232 assertEquals(5, arr.dimensions[0]);
233 assertEquals(1, (int) arr.get(0, 0));
234 assertEquals(2, (int) arr.get(0, 1));
235 assertEquals(3, (int) arr.get(1, 0));
236 assertEquals(4, (int) arr.get(1, 1));
237 assertEquals(5, (int) arr.get(2, 0));
238 assertEquals(6, (int) arr.get(2, 1));
239 arr.set(7, 3, 0);
240 arr.set(8, 3, 1);
241 arr.decNumberOfHyperRows(1);
242 assertEquals(4, arr.dimensions[0]);
243 assertEquals(1, (int) arr.get(0, 0));
244 assertEquals(2, (int) arr.get(0, 1));
245 assertEquals(3, (int) arr.get(1, 0));
246 assertEquals(4, (int) arr.get(1, 1));
247 assertEquals(5, (int) arr.get(2, 0));
248 assertEquals(6, (int) arr.get(2, 1));
249 assertEquals(7, (int) arr.get(3, 0));
250 assertEquals(8, (int) arr.get(3, 1));
251 }
252
253 @Test
254 public void testMDIntArrayIterator()
255 {
256 final int[] linArray = new int[120];
257 for (int i = 0; i < linArray.length; ++i)
258 {
259 linArray[i] = i;
260 }
261 final MDIntArray array = new MDIntArray(linArray, new int[]
262 { 2, 3, 4, 5 });
263 for (MDIntArray.ArrayEntry e : array)
264 {
265 assertEquals(e.getLinearIndex(), e.getValue().intValue());
266 assertEquals(e.getLinearIndex(), array.computeIndex(e.getIndex()));
267 }
268 }
269
270 @Test
271 public void testMDFloatArrayMatrix()
272 {
273 final float[][] matrix1 = new float[][]
274 {
275 { 1f, 2f, 3f, 4f },
276 { 5f, 6f, 7f, 8f },
277 { 9f, 10f, 11f, 12f } };
278 final MDFloatArray array = new MDFloatArray(matrix1);
279 assertEquals(2, array.rank());
280 assertEquals(12, array.size());
281 assertEquals(3, array.size(0));
282 assertEquals(4, array.size(1));
283 assertEquals(7f, array.get(1, 2));
284 final float[][] matrix2 = array.toMatrix();
285 assertEquals(matrix1.length, matrix2.length);
286 for (int i = 0; i < matrix1.length; ++i)
287 {
288 assertTrue(Arrays.equals(matrix1[i], matrix2[i]));
289 }
290 }
291
292 @Test
293 public void testCloneMDArray()
294 {
295 final float[][] matrix1 = new float[][]
296 {
297 { 1f, 2f, 3f, 4f },
298 { 5f, 6f, 7f, 8f },
299 { 9f, 10f, 11f, 12f } };
300 final MDFloatArray array = new MDFloatArray(matrix1);
301 final MDFloatArray array2 = array.clone();
302 assertNotSame(array2.getAsFlatArray(), array.getAsFlatArray());
303 assertNotSame(array2.dimensions, array.dimensions);
304 assertEquals(array2.hyperRowLength, array.hyperRowLength);
305 assertEquals(array2.capacityHyperRows, array.capacityHyperRows);
306 assertEquals(array2.size, array.size);
307 assertEquals(2, array2.rank());
308 assertEquals(12, array2.size());
309 assertEquals(3, array2.size(0));
310 assertEquals(4, array2.size(1));
311 assertEquals(7f, array2.get(1, 2));
312 final float[][] matrix2 = array2.toMatrix();
313 assertEquals(matrix1.length, matrix2.length);
314 for (int i = 0; i < matrix1.length; ++i)
315 {
316 assertTrue(Arrays.equals(matrix1[i], matrix2[i]));
317 }
318 }
319
320 public static void main(String[] args) throws Throwable
321 {
322 System.out.println(BuildAndEnvironmentInfo.INSTANCE);
323 System.out.println("Test class: " + MDArrayTests.class.getSimpleName());
324 System.out.println();
325 final MDArrayTests test = new MDArrayTests();
326 for (Method m : MDArrayTests.class.getMethods())
327 {
328 final Test testAnnotation = m.getAnnotation(Test.class);
329 if (testAnnotation == null)
330 {
331 continue;
332 }
333 if (m.getParameterTypes().length == 0)
334 {
335 System.out.println("Running " + m.getName());
336 try
337 {
338 m.invoke(test);
339 } catch (InvocationTargetException wrapperThrowable)
340 {
341 final Throwable th = wrapperThrowable.getCause();
342 boolean exceptionFound = false;
343 for (Class<?> expectedExClazz : testAnnotation.expectedExceptions())
344 {
345 if (expectedExClazz == th.getClass())
346 {
347 exceptionFound = true;
348 break;
349 }
350 }
351 if (exceptionFound == false)
352 {
353 throw th;
354 }
355 }
356 }
357 }
358 System.out.println("Tests OK!");
359 }
360
361 }