GRASS Programmer's Manual  6.4.2(2012)
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
test_arrays.c
Go to the documentation of this file.
1 
2 /*****************************************************************************
3 *
4 * MODULE: Grass PDE Numerical Library
5 * AUTHOR(S): Soeren Gebbert, Berlin (GER) Dec 2006
6 * soerengebbert <at> gmx <dot> de
7 *
8 * PURPOSE: Unit tests for arrays
9 *
10 * COPYRIGHT: (C) 2000 by the GRASS Development Team
11 *
12 * This program is free software under the GNU General Public
13 * License (>=v2). Read the file COPYING that comes with GRASS
14 * for details.
15 *
16 *****************************************************************************/
17 
18 
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <grass/glocale.h>
23 #include <grass/N_pde.h>
24 #include "test_gpde_lib.h"
25 
26 /* prototypes */
27 static int fill_array_2d(N_array_2d * a);
28 static int fill_array_2d_null(N_array_2d * a);
29 static int compare_array_2d(N_array_2d * a, N_array_2d * b);
30 static int fill_array_3d(N_array_3d * a);
31 static int fill_array_3d_null(N_array_3d * a);
32 static int compare_array_3d(N_array_3d * a, N_array_3d * b);
33 static int test_array_2d(void);
34 static int test_array_3d(void);
35 static int io_bench_2d(void);
36 static int io_bench_3d(void);
37 
38 /* ************************************************************************* */
39 /* Performe the array unit tests ******************************************* */
40 /* ************************************************************************* */
42 {
43  int sum = 0;
44 
45  io_bench_2d();
46  return sum;
47 
48  G_message(_("\n++ Running array unit tests ++"));
49 
50  G_message(_("\t 1. testing 2d arrays"));
51  sum += test_array_2d();
52 
53  G_message(_("\t 2. testing 3d arrays"));
54  sum += test_array_3d();
55 
56  if (sum > 0)
57  G_warning(_("\n-- Array unit tests failure --"));
58  else
59  G_message(_("\n-- Array unit tests finished successfully --"));
60 
61  return sum;
62 }
63 
64 /* ************************************************************************* */
65 /* Fill an 2d array with valid data **************************************** */
66 /* ************************************************************************* */
67 int fill_array_2d(N_array_2d * a)
68 {
69  int rows, cols, type;
70  int i, j, res = 0;
71 
72  rows = a->rows;
73  cols = a->cols;
74  type = N_get_array_2d_type(a);
75 
76 #pragma omp parallel for private (i, j) shared (cols, rows, type, a) reduction(+:res)
77  for (j = 0; j < rows; j++) {
78  for (i = 0; i < cols; i++) {
79  if (type == CELL_TYPE) {
80  N_put_array_2d_c_value(a, i, j, (CELL) i * (CELL) j);
81  if (N_get_array_2d_c_value(a, i, j) != (CELL) i * (CELL) j)
82  res++;
83  }
84  if (type == FCELL_TYPE) {
85  N_put_array_2d_f_value(a, i, j, (FCELL) i * (FCELL) j);
86  if (N_get_array_2d_f_value(a, i, j) != (FCELL) i * (FCELL) j)
87  res++;
88  }
89  if (type == DCELL_TYPE) {
90  N_put_array_2d_d_value(a, i, j, (DCELL) i * (DCELL) j);
91  if (N_get_array_2d_d_value(a, i, j) != (DCELL) i * (DCELL) j)
92  res++;
93  }
94  }
95  }
96 
97  return res;
98 }
99 
100 /* ************************************************************************* */
101 /* Fill an 2d array with null values *************************************** */
102 /* ************************************************************************* */
103 int fill_array_2d_null(N_array_2d * a)
104 {
105  int rows, cols;
106  int i, j, res = 0;
107 
108  cols = a->cols;
109  rows = a->rows;
110 
111 #pragma omp parallel for private (i, j) shared (rows, cols, a) reduction(+:res)
112  for (j = 0; j < rows; j++) {
113  for (i = 0; i < cols; i++) {
114  N_put_array_2d_value_null(a, i, j);
115  if (!N_is_array_2d_value_null(a, i, j))
116  res++;
117  }
118  }
119 
120  return res;
121 }
122 
123 /* ************************************************************************* */
124 /* Compare two 2d arrays *************************************************** */
125 /* ************************************************************************* */
126 int compare_array_2d(N_array_2d * a, N_array_2d * b)
127 {
128  int rows, cols, type;
129  int i, j, res = 0;
130 
131  cols = a->cols;
132  rows = a->rows;
133  type = N_get_array_2d_type(a);
134 
135 #pragma omp parallel for private (i, j) shared (cols, rows, type, a, b) reduction(+:res)
136  for (j = 0; j < rows; j++) {
137  for (i = 0; i < cols; i++) {
138  if (type == CELL_TYPE) {
139  if (N_get_array_2d_c_value(a, i, j) !=
140  N_get_array_2d_c_value(b, i, j))
141  res++;
142  }
143  if (type == FCELL_TYPE) {
144  if (N_get_array_2d_f_value(a, i, j) !=
145  N_get_array_2d_f_value(b, i, j))
146  res++;
147  }
148  if (type == DCELL_TYPE) {
149  if (N_get_array_2d_d_value(a, i, j) !=
150  N_get_array_2d_d_value(b, i, j))
151  res++;
152  }
153  }
154  }
155 
156  return res;
157 }
158 
159 /* ************************************************************************* */
160 /* Fill an 3d array with valid data **************************************** */
161 /* ************************************************************************* */
162 int fill_array_3d(N_array_3d * a)
163 {
164  int rows, cols, depths, type;
165  int i, j, k, res = 0;
166 
167  cols = a->cols;
168  rows = a->rows;
169  depths = a->depths;
170  type = N_get_array_3d_type(a);
171 
172 #pragma omp parallel for private (i, j, k) shared (depths, rows, cols, type, a) reduction(+:res)
173  for (k = 0; k < depths; k++) {
174  for (j = 0; j < rows; j++) {
175  for (i = 0; i < cols; i++) {
176  if (type == FCELL_TYPE) {
177  N_put_array_3d_f_value(a, i, j, k,
178  (float)i * (float)j * (float)k);
179  if (N_get_array_3d_f_value(a, i, j, k) !=
180  (float)i * (float)j * (float)k)
181  res++;
182  }
183  if (type == DCELL_TYPE) {
184  N_put_array_3d_d_value(a, i, j, k,
185  (double)i * (double)j * (double)k);
186  if (N_get_array_3d_d_value(a, i, j, k) !=
187  (double)i * (double)j * (double)k)
188  res++;
189  }
190  }
191  }
192  }
193 
194  return res;
195 }
196 
197 /* ************************************************************************* */
198 /* Fill an 3d array with null data ***************************************** */
199 /* ************************************************************************* */
200 int fill_array_3d_null(N_array_3d * a)
201 {
202  int rows, cols, depths, type;
203  int i, j, k, res = 0;
204 
205  cols = a->cols;
206  rows = a->rows;
207  depths = a->depths;
208  type = N_get_array_3d_type(a);
209 
210 #pragma omp parallel for private (i, j, k) shared (cols, rows, depths, type, a) reduction(+:res)
211  for (k = 0; k < depths; k++) {
212  for (j = 0; j < rows; j++) {
213  for (i = 0; i < cols; i++) {
214  N_put_array_3d_value_null(a, i, j, k);
215  if (!N_is_array_3d_value_null(a, i, j, k))
216  res++;
217  }
218  }
219  }
220 
221  return res;
222 }
223 
224 /* ************************************************************************* */
225 /* Compare two 3d arrays *************************************************** */
226 /* ************************************************************************* */
227 int compare_array_3d(N_array_3d * a, N_array_3d * b)
228 {
229  int rows, cols, depths, type;
230  int i, j, k, res = 0;
231 
232  rows = a->rows;
233  cols = a->cols;
234  depths = a->depths;
235  type = N_get_array_3d_type(a);
236 
237 #pragma omp parallel for private (i, j, k) shared (depths, rows, cols, type, a, b) reduction(+:res)
238  for (k = 0; k < depths; k++) {
239  for (i = 0; i < rows; i++) {
240  for (j = 0; j < cols; j++) {
241  if (type == FCELL_TYPE) {
242  if (N_get_array_3d_f_value(a, i, j, k) !=
243  N_get_array_3d_f_value(b, i, j, k))
244  res++;
245  }
246  if (type == DCELL_TYPE) {
247  if (N_get_array_3d_d_value(a, i, j, k) !=
248  N_get_array_3d_d_value(b, i, j, k))
249  res++;
250  }
251  }
252  }
253  }
254 
255  return res;
256 }
257 
258 /* *************************************************************** */
259 /* *************************************************************** */
260 /* *************************************************************** */
261 int io_bench_2d(void)
262 {
263  int sum = 0, res = 0;
264  char buff[1024];
265 
266  struct Cell_head region;
267  N_array_2d *data1;
268  N_array_2d *data2;
269  N_array_2d *data3;
270  N_array_2d *tmp;
271 
272  G_get_set_window(&region);
273 
274  data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
275  data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
276  data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
277 
278  fill_array_2d(data1);
279  fill_array_2d(data2);
280  fill_array_2d(data3);
281 
282  /*raster IO methods */
283  N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
284  N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
285  N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
286  tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
287  N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
288  N_free_array_2d(tmp);
289  tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
290  N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
291  N_free_array_2d(tmp);
292  tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
293  N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
294  N_free_array_2d(tmp);
295 
296 
297  sprintf(buff,
298  "g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
299  system(buff);
300 
301  N_free_array_2d(data1);
302  N_free_array_2d(data2);
303  N_free_array_2d(data3);
304 
305  return sum;
306 }
307 
308 
309 /* *************************************************************** */
310 /* *************************************************************** */
311 /* *************************************************************** */
312 int test_array_2d(void)
313 {
314  int sum = 0, res = 0;
315 
316  struct Cell_head region;
317  N_array_2d *data1;
318  N_array_2d *data11;
319  N_array_2d *data2;
320  N_array_2d *data22;
321  N_array_2d *data3;
322  N_array_2d *data33;
323  char buff[1024];
324  double min, max, ssum;
325  int nonzero;
326 
327  N_array_2d *tmp;
328 
329  /*Alloacte memory for all arrays */
330  data1 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
331  N_print_array_2d_info(data1);
332  data11 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
333  data2 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
334  N_print_array_2d_info(data2);
335  data22 =
337  data3 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
338  N_print_array_2d_info(data3);
339  data33 =
341 
342  /*Fill the first arrays with data */
343 
344  res = fill_array_2d(data1);
345  if (res != 0)
346  G_warning("test_array_2d: error while filling array with values");
347  sum += res;
348  res = fill_array_2d(data2);
349  if (res != 0)
350  G_warning("test_array_2d: error while filling array with values");
351  sum += res;
352  res = fill_array_2d(data3);
353  if (res != 0)
354  G_warning("test_array_2d: error while filling array with values");
355  sum += res;
356 
357  /*Copy the data */
358  N_copy_array_2d(data1, data11);
359  N_copy_array_2d(data2, data22);
360  N_copy_array_2d(data3, data33);
361 
362  /*Compare the data */
363  res = compare_array_2d(data1, data11);
364  if (res != 0)
365  G_warning("test_array_2d: error in N_copy_array_2d");
366  sum += res;
367  res = compare_array_2d(data2, data22);
368  if (res != 0)
369  G_warning("test_array_2d: error in N_copy_array_2d");
370  sum += res;
371  res = compare_array_2d(data3, data33);
372  if (res != 0)
373  G_warning("test_array_2d: error in N_copy_array_2d");
374  sum += res;
375 
376  /*compute statistics */
377  N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 0);
378  G_message("CELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
379  nonzero);
380  if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
381  G_warning("test_array_2d: error in N_calc_array_2d_stats");
382  sum++;
383  }
384  N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 1);
385  G_message("CELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
386  nonzero);
387  if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
388  G_warning("test_array_2d: error in N_calc_array_2d_stats");
389  sum++;
390  }
391 
392  N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 0);
393  G_message("FCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
394  nonzero);
395  if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
396  G_warning("test_array_2d: error in N_calc_array_2d_stats");
397  sum++;
398  }
399 
400  N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 1);
401  G_message("FCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
402  nonzero);
403  if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
404  G_warning("test_array_2d: error in N_calc_array_2d_stats");
405  sum++;
406  }
407 
408  N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 0);
409  G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
410  nonzero);
411  if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
412  G_warning("test_array_2d: error in N_calc_array_2d_stats");
413  sum++;
414  }
415 
416  N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 1);
417  G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
418  nonzero);
419  if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
420  G_warning("test_array_2d: error in N_calc_array_2d_stats");
421  sum++;
422  }
423 
424 
425 
426  /*test the array math functions */
427  tmp = N_math_array_2d(data1, data2, NULL, N_ARRAY_SUM);
428  N_math_array_2d(data2, data2, tmp, N_ARRAY_SUM);
430  if (res != 0)
431  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
432  sum = res;
433  N_free_array_2d(tmp);
434 
435  tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIF);
436  N_math_array_2d(data1, data2, tmp, N_ARRAY_DIF);
438  if (res != 0)
439  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
440  sum = res;
441  N_free_array_2d(tmp);
442 
443  tmp = N_math_array_2d(data1, data1, NULL, N_ARRAY_MUL);
444  N_math_array_2d(data1, data1, tmp, N_ARRAY_MUL);
446  if (res != 0)
447  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
448  sum = res;
449  N_free_array_2d(tmp);
450 
451  tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
452  N_math_array_2d(data1, data2, tmp, N_ARRAY_DIV);
454  if (res == 0) { /* if a division with zero is detected, the value is set to null, not to nan */
455  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
456  sum++;
457  }
458  N_free_array_2d(tmp);
459 
460 
461 
462  /*check for correct norm calculation */
463  if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
464  G_warning("test_array_2d: error in N_norm_array_2d");
465  sum++;
466  }
467  if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
468  G_warning("test_array_2d: error in N_norm_array_2d");
469  sum++;
470  }
471 
472  if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
473  G_warning("test_array_2d: error in N_norm_array_2d");
474  sum++;
475  }
476  if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
477  G_warning("test_array_2d: error in N_norm_array_2d");
478  sum++;
479  }
480 
481  /*fill arrays with null values */
482  res = fill_array_2d_null(data1);
483  if (res != 0)
484  G_warning
485  ("test_array_2d: error while filling array with cell null values");
486  sum += res;
487  res = fill_array_2d_null(data2);
488  if (res != 0)
489  G_warning
490  ("test_array_2d: error while filling array with fcell null values");
491  sum += res;
492  res = fill_array_2d_null(data3);
493  if (res != 0)
494  G_warning
495  ("test_array_2d: error while filling array with dcell null values");
496  sum += res;
497 
498  /*Copy the data */
499  N_copy_array_2d(data1, data11);
500  N_copy_array_2d(data2, data22);
501  N_copy_array_2d(data3, data33);
502 
503  /*Compare the data */
504  compare_array_2d(data1, data11);
505  compare_array_2d(data2, data22);
506  compare_array_2d(data3, data33);
507 
508  /*check for correct norm calculation in case of null values */
509  if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
510  G_warning("test_array_2d: error in N_norm_array_2d");
511  sum++;
512  }
513  if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
514  G_warning("test_array_2d: error in N_norm_array_2d");
515  sum++;
516  }
517 
518  if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
519  G_warning("test_array_2d: error in N_norm_array_2d");
520  sum++;
521  }
522  if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
523  G_warning("test_array_2d: error in N_norm_array_2d");
524  sum++;
525  }
526 
527  /*test the array math functions with null values */
528  tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_SUM);
529  N_math_array_2d(data2, data22, tmp, N_ARRAY_SUM);
531  if (res == 0) {
532  G_warning
533  ("test_array_2d: error in N_convert_array_2d_null_to_zero ");
534  sum++;
535  }
536  N_free_array_2d(tmp);
537 
538  tmp = N_math_array_2d(data2, data22, NULL, N_ARRAY_DIF);
539  N_math_array_2d(data3, data33, tmp, N_ARRAY_DIF);
541  if (res == 0) {
542  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
543  sum++;
544  }
545  N_free_array_2d(tmp);
546 
547  tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_MUL);
548  N_math_array_2d(data3, data33, tmp, N_ARRAY_MUL);
550  if (res == 0) {
551  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
552  sum++;
553  }
554  N_free_array_2d(tmp);
555 
556  tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
557  N_math_array_2d(data1, data11, tmp, N_ARRAY_DIV);
559  if (res == 0) {
560  G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
561  sum++;
562  }
563  N_free_array_2d(tmp);
564 
565 
566  N_free_array_2d(data1);
567  N_free_array_2d(data2);
568  N_free_array_2d(data3);
569 
570  G_get_set_window(&region);
571 
572  data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
573  data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
574  data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
575  fill_array_2d(data1);
576  fill_array_2d(data2);
577  fill_array_2d(data3);
578 
579  /*raster IO methods */
580  N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
581  N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
582  N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
583  tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
584  N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
585  N_free_array_2d(tmp);
586  tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
587  N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
588  N_free_array_2d(tmp);
589  tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
590  N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
591  N_free_array_2d(tmp);
592 
593 
594  sprintf(buff,
595  "g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
596  system(buff);
597 
598 
599 
600  N_free_array_2d(data1);
601  N_free_array_2d(data11);
602  N_free_array_2d(data2);
603  N_free_array_2d(data22);
604  N_free_array_2d(data3);
605  N_free_array_2d(data33);
606 
607  return sum;
608 }
609 
610 /* *************************************************************** */
611 /* *************************************************************** */
612 /* *************************************************************** */
613 int test_array_3d(void)
614 {
615  int sum = 0, res = 0;
616  char buff[1024];
617  G3D_Region region;
618 
619  N_array_3d *data1;
620  N_array_3d *data11;
621  N_array_3d *data2;
622  N_array_3d *data22;
623 
624  N_array_3d *tmp;
625  double min, max, ssum;
626  int nonzero;
627 
628  /*Alloacte memory for all arrays */
629  data1 =
631  2, FCELL_TYPE);
632  N_print_array_3d_info(data1);
633  data11 =
635  2, FCELL_TYPE);
636  data2 =
638  2, DCELL_TYPE);
639  N_print_array_3d_info(data2);
640  data22 =
642  2, DCELL_TYPE);
643 
644 
645  /*Fill the first arrays with data */
646 
647  res = fill_array_3d(data1);
648  if (res != 0)
649  G_warning("test_array_3d: error while filling array with values");
650  sum += res;
651  res = fill_array_3d(data2);
652  if (res != 0)
653  G_warning("test_array_3d: error while filling array with values");
654  sum += res;
655 
656  /*Copy the data */
657  N_copy_array_3d(data1, data11);
658  N_copy_array_3d(data2, data22);
659 
660  /*Compare the data */
661  res = compare_array_3d(data1, data11);
662  if (res != 0)
663  G_warning("test_array_3d: error in N_copy_array_2d");
664  sum += res;
665  res = compare_array_3d(data1, data11);
666  if (res != 0)
667  G_warning("test_array_3d: error in N_copy_array_2d");
668  sum += res;
669 
670 
671 
672  /*compute statistics */
673  N_calc_array_3d_stats(data1, &min, &max, &ssum, &nonzero, 0);
674  G_message("FELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
675  nonzero);
676  if (min != 0 || max != 729 || ssum != 91125 || nonzero != 1000) {
677  G_warning("test_array_3d: error in N_calc_array_3d_stats");
678  sum++;
679  }
680  N_calc_array_3d_stats(data1, &min, &max, &ssum, &nonzero, 1);
681  G_message("FELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
682  nonzero);
683  if (min != 0 || max != 729 || ssum != 91125 || nonzero != 2744) {
684  G_warning("test_array_3d: error in N_calc_array_3d_stats");
685  sum++;
686  }
687 
688  N_calc_array_3d_stats(data2, &min, &max, &ssum, &nonzero, 0);
689  G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
690  nonzero);
691  if (min != 0 || max != 729 || ssum != 91125 || nonzero != 1000) {
692  G_warning("test_array_3d: error in N_calc_array_3d_stats");
693  sum++;
694  }
695 
696  N_calc_array_3d_stats(data2, &min, &max, &ssum, &nonzero, 1);
697  G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
698  nonzero);
699  if (min != 0 || max != 729 || ssum != 91125 || nonzero != 2744) {
700  G_warning("test_array_3d: error in N_calc_array_3d_stats");
701  sum++;
702  }
703 
704 
705  /*test the array math functions */
706  tmp = N_math_array_3d(data1, data2, NULL, N_ARRAY_SUM);
707  N_math_array_3d(data2, data2, tmp, N_ARRAY_SUM);
709  if (res != 0)
710  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
711  sum = res;
712  N_free_array_3d(tmp);
713 
714  tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIF);
715  N_math_array_3d(data1, data2, tmp, N_ARRAY_DIF);
717  if (res != 0)
718  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
719  sum = res;
720  N_free_array_3d(tmp);
721 
722  tmp = N_math_array_3d(data1, data1, NULL, N_ARRAY_MUL);
723  N_math_array_3d(data1, data1, tmp, N_ARRAY_MUL);
725  if (res != 0)
726  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
727  sum = res;
728  N_free_array_3d(tmp);
729 
730  tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIV);
731  N_math_array_3d(data1, data2, tmp, N_ARRAY_DIV);
733  if (res == 0) { /* if a division with zero is detected, the value is set to null, not to nan */
734  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
735  sum++;
736  }
737  N_free_array_3d(tmp);
738 
739 
740  /*check for correct norm calculation */
741  if (N_norm_array_3d(data1, data11, N_EUKLID_NORM) != 0.0) {
742  G_warning("test_array_3d: error in N_norm_array_3d");
743  sum++;
744  }
745  if (N_norm_array_3d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
746  G_warning("test_array_3d: error in N_norm_array_3d");
747  sum++;
748  }
749 
750  if (N_norm_array_3d(data1, data2, N_EUKLID_NORM) != 0.0) {
751  G_warning("test_array_3d: error in N_norm_array_3d");
752  sum++;
753  }
754  if (N_norm_array_3d(data1, data2, N_MAXIMUM_NORM) != 0.0) {
755  G_warning("test_array_3d: error in N_norm_array_3d");
756  sum++;
757  }
758 
759  /*fill arrays with null values */
760  res = fill_array_3d_null(data1);
761  if (res != 0)
762  G_warning
763  ("test_array_3d: error while filling array with float null values");
764  sum += res;
765  res = fill_array_3d_null(data2);
766  if (res != 0)
767  G_warning
768  ("test_array_3d: error while filling array with double null values");
769  sum += res;
770 
771  /*Copy the data */
772  N_copy_array_3d(data1, data11);
773  N_copy_array_3d(data2, data22);
774 
775  /*Compare the data */
776  compare_array_3d(data1, data11);
777  compare_array_3d(data2, data22);
778 
779  /*test the array math functions */
780  tmp = N_math_array_3d(data1, data2, NULL, N_ARRAY_SUM);
781  N_math_array_3d(data2, data2, tmp, N_ARRAY_SUM);
783  if (res == 0) {
784  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
785  sum++;
786  }
787  N_free_array_3d(tmp);
788 
789  tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIF);
790  N_math_array_3d(data1, data2, tmp, N_ARRAY_DIF);
792  if (res == 0) {
793  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
794  sum++;
795  }
796  N_free_array_3d(tmp);
797 
798  tmp = N_math_array_3d(data1, data1, NULL, N_ARRAY_MUL);
799  N_math_array_3d(data1, data1, tmp, N_ARRAY_MUL);
801  if (res == 0) {
802  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
803  sum++;
804  }
805  N_free_array_3d(tmp);
806 
807  tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIV);
808  N_math_array_3d(data1, data2, tmp, N_ARRAY_DIV);
810  if (res == 0) {
811  G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
812  sum++;
813  }
814  N_free_array_3d(tmp);
815 
816 
817  /*check for correct norm calculation in case of null values */
818  if (N_norm_array_3d(data1, data11, N_EUKLID_NORM) != 0.0) {
819  G_warning("test_array_3d: error in N_norm_array_3d");
820  sum++;
821  }
822  if (N_norm_array_3d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
823  G_warning("test_array_3d: error in N_norm_array_3d");
824  sum++;
825  }
826 
827  if (N_norm_array_3d(data1, data2, N_EUKLID_NORM) != 0.0) {
828  G_warning("test_array_3d: error in N_norm_array_3d");
829  sum++;
830  }
831  if (N_norm_array_3d(data1, data2, N_MAXIMUM_NORM) != 0.0) {
832  G_warning("test_array_3d: error in N_norm_array_3d");
833  sum++;
834  }
835 
836  N_free_array_3d(data1);
837  N_free_array_3d(data2);
838 
839  /*Set the defaults */
841  G3d_getWindow(&region);
842 
843  data1 =
844  N_alloc_array_3d(region.cols, region.rows, region.depths, 0,
845  FCELL_TYPE);
846  data2 =
847  N_alloc_array_3d(region.cols, region.rows, region.depths, 0,
848  DCELL_TYPE);
849  fill_array_3d(data1);
850  fill_array_3d(data2);
851 
852 
853  /*Volume IO methods */
854  N_write_array_3d_to_rast3d(data1, "gpde_lib_test_volume_1", 1);
855  N_write_array_3d_to_rast3d(data2, "gpde_lib_test_volume_2", 1);
856  tmp = N_read_rast3d_to_array_3d("gpde_lib_test_volume_1", NULL, 1);
857  N_read_rast3d_to_array_3d("gpde_lib_test_volume_1", tmp, 1);
858  N_free_array_3d(tmp);
859  tmp = N_read_rast3d_to_array_3d("gpde_lib_test_volume_2", NULL, 1);
860  N_read_rast3d_to_array_3d("gpde_lib_test_volume_2", tmp, 1);
861  N_free_array_3d(tmp);
862 
863  sprintf(buff,
864  "g.remove rast3d=gpde_lib_test_volume_1,gpde_lib_test_volume_2");
865  system(buff);
866 
867  N_free_array_3d(data1);
868  N_free_array_3d(data11);
869  N_free_array_3d(data2);
870  N_free_array_3d(data22);
871 
872  return sum;
873 }