PostGIS  3.4.0dev-r@@SVN_REVISION@@

◆ test_lwprint()

static void test_lwprint ( void  )
static

Definition at line 269 of file cu_print.c.

270 {
271  static const int precision_start = -1; /* Check for negatives */
272  static const int precision_end = OUT_MAX_DIGITS + 2; /* Ask for more digits than available in all cases */
273 
274  /* Negative zero should be printed as 0 */
275  for (int i = precision_start; i < precision_end; i++)
276  assert_lwprint_equal(-0, i, "0");
277 
278  /* 2 = 0x4000000000000000
279  * -2 = 0xC000000000000000
280  * Both with exact representation, so we should never see extra digits
281  */
282  for (int i = precision_start; i < precision_end; i++)
283  {
284  assert_lwprint_equal(2.0, i, "2");
285  assert_lwprint_equal(-2.0, i, "-2");
286  }
287 
288  /* 0.3 doesn't have an exact representation but it's the shortest representation for 0x3FD3333333333333
289  * 2.99999999999999988897769753748E-1 = 0x3FD3333333333333
290  */
291  assert_lwprint_equal(0.3, 0, "0");
292  for (int i = 1; i < precision_end; i++)
293  {
294  assert_lwprint_equal(0.3, i, "0.3");
295  assert_lwprint_equal(2.99999999999999988897769753748E-1, i, "0.3");
296  }
297 
298  /* 2.5 has an exact representation (0x4004000000000000) */
299  assert_lwprint_equal(2.5, 0, "2");
300  for (int i = 1; i < precision_end; i++)
301  {
302  assert_lwprint_equal(2.5, i, "2.5");
303  }
304 
305  /* Test trailing zeros and rounding
306  * 0.0000000298023223876953125 == 0x3E60000000000000 == 2.98023223876953125E-8
307  */
308  assert_lwprint_equal(0.0000000298023223876953125, -1, "0");
309  assert_lwprint_equal(0.0000000298023223876953125, 0, "0");
310  assert_lwprint_equal(0.0000000298023223876953125, 1, "0");
311  assert_lwprint_equal(0.0000000298023223876953125, 2, "0");
312  assert_lwprint_equal(0.0000000298023223876953125, 3, "0");
313  assert_lwprint_equal(0.0000000298023223876953125, 4, "0");
314  assert_lwprint_equal(0.0000000298023223876953125, 5, "0");
315  assert_lwprint_equal(0.0000000298023223876953125, 6, "0");
316  assert_lwprint_equal(0.0000000298023223876953125, 7, "0");
317  assert_lwprint_equal(0.0000000298023223876953125, 8, "0.00000003");
318  assert_lwprint_equal(0.0000000298023223876953125, 9, "0.00000003");
319  assert_lwprint_equal(0.0000000298023223876953125, 10, "0.0000000298");
320  assert_lwprint_equal(0.0000000298023223876953125, 11, "0.0000000298");
321  assert_lwprint_equal(0.0000000298023223876953125, 12, "0.000000029802");
322  assert_lwprint_equal(0.0000000298023223876953125, 13, "0.0000000298023");
323  assert_lwprint_equal(0.0000000298023223876953125, 14, "0.00000002980232");
324  assert_lwprint_equal(0.0000000298023223876953125, 15, "0.000000029802322");
325  assert_lwprint_equal(0.0000000298023223876953125, 16, "0.0000000298023224");
326  assert_lwprint_equal(0.0000000298023223876953125, 17, "0.00000002980232239");
327  assert_lwprint_equal(0.0000000298023223876953125, 18, "0.000000029802322388");
328  assert_lwprint_equal(0.0000000298023223876953125, 19, "0.0000000298023223877");
329  assert_lwprint_equal(0.0000000298023223876953125, 20, "0.0000000298023223877");
330  assert_lwprint_equal(0.0000000298023223876953125, 21, "0.000000029802322387695");
331  assert_lwprint_equal(0.0000000298023223876953125, 22, "0.0000000298023223876953");
332  assert_lwprint_equal(0.0000000298023223876953125, 23, "0.00000002980232238769531");
333  assert_lwprint_equal(0.0000000298023223876953125, 24, "0.000000029802322387695312");
334  assert_lwprint_equal(0.0000000298023223876953125, 40, "0.000000029802322387695312");
335 
336  /* Negative 0 after rounding should be printed as 0 */
337  assert_lwprint_equal(-0.0005, 0, "0");
338  assert_lwprint_equal(-0.0005, 1, "0");
339  assert_lwprint_equal(-0.0005, 2, "0");
340  assert_lwprint_equal(-0.0005, 3, "0");
341  assert_lwprint_equal(-0.0005, 4, "-0.0005");
342 
343  /* Rounding on the first decimal digit */
344  assert_lwprint_equal(-2.5, 0, "-2");
345  assert_lwprint_equal(-1.5, 0, "-2");
346  assert_lwprint_equal(-0.99, 0, "-1");
347  assert_lwprint_equal(-0.5, 0, "0");
348  assert_lwprint_equal(-0.01, 0, "0");
349  assert_lwprint_equal(0.5, 0, "0");
350  assert_lwprint_equal(0.99, 0, "1");
351  assert_lwprint_equal(1.5, 0, "2");
352  assert_lwprint_equal(2.5, 0, "2");
353 
354  /* Check rounding */
355  assert_lwprint_equal(0.035, 2, "0.04");
356  assert_lwprint_equal(0.045, 2, "0.04");
357  assert_lwprint_equal(0.04500000000000001, 2, "0.05");
358  assert_lwprint_equal(0.077, 2, "0.08");
359  assert_lwprint_equal(0.087, 2, "0.09");
360  assert_lwprint_equal(1.05, 1, "1");
361  assert_lwprint_equal(1.005, 2, "1");
362  assert_lwprint_equal(2.05, 1, "2");
363  assert_lwprint_equal(2.005, 2, "2");
364 
365  for (int i = 0; i < 15; i++)
366  assert_lwprint_equal(-0.99999999999999988898, i, "-1");
367  for (int i = 15; i < 20; i++)
368  assert_lwprint_equal(-0.99999999999999988898, i, "-0.9999999999999999");
369 
370  for (int i = 0; i < 16; i++)
371  assert_lwprint_equal(0.99999999999999977796, i, "1");
372  for (int i = 16; i < 20; i++)
373  assert_lwprint_equal(0.99999999999999977796, i, "0.9999999999999998");
374 
375  assert_lwprint_equal(0.0999999999999999916733273153113, 0, "0");
376  assert_lwprint_equal(-0.0999999999999999916733273153113, 0, "0");
377  for (int i = 1; i < 15; i++)
378  {
379  assert_lwprint_equal(0.0999999999999999916733273153113, i, "0.1");
380  assert_lwprint_equal(-0.0999999999999999916733273153113, i, "-0.1");
381  }
382 
383  assert_lwprint_equal(0.00999999999999999847, 0, "0");
384  assert_lwprint_equal(-0.00999999999999999847, 0, "0");
385  assert_lwprint_equal(0.00999999999999999847, 1, "0");
386  assert_lwprint_equal(-0.00999999999999999847, 1, "0");
387  for (int i = 2; i < 15; i++)
388  {
389  assert_lwprint_equal(0.00999999999999999847, i, "0.01");
390  assert_lwprint_equal(-0.00999999999999999847, i, "-0.01");
391  }
392 
393  /* Test regression changes (output that changed in the tests vs 3.0) */
394  /* There is at most 17 significative digits */
395  assert_lwprint_equal(-123456789012345.12345678, 20, "-123456789012345.12");
396  assert_lwprint_equal(123456789012345.12345678, 20, "123456789012345.12");
397 
398  /* Precision is respected (as number of decimal digits) */
399  assert_lwprint_equal(92115.51207431706, 12, "92115.51207431706");
400  assert_lwprint_equal(463412.82600000006, 12, "463412.82600000006");
401  assert_lwprint_equal(463462.2069374289, 12, "463462.2069374289");
402  assert_lwprint_equal(-115.17281600000001, OUT_DEFAULT_DECIMAL_DIGITS, "-115.17281600000001");
403  assert_lwprint_equal(-115.17281600000001, 12, "-115.172816");
404  assert_lwprint_equal(36.11464599999999, OUT_DEFAULT_DECIMAL_DIGITS, "36.11464599999999");
405  assert_lwprint_equal(36.11464599999999, 12, "36.114646");
406  assert_lwprint_equal(400000, 0, "400000");
407  assert_lwprint_equal(400000, 12, "400000");
408  assert_lwprint_equal(400000, 20, "400000");
409  assert_lwprint_equal(5.0833333333333330372738600999582558870316, 15, "5.083333333333333");
410  assert_lwprint_equal(1.4142135623730951, 15, "1.414213562373095");
411  assert_lwprint_equal(143.62025166838282, 15, "143.62025166838282");
412  assert_lwprint_equal(-30.037497356076827, 15, "-30.037497356076827");
413  assert_lwprint_equal(142.92857147299705, 15, "142.92857147299705");
414  assert_lwprint_equal(-32.75101196874403, 15, "-32.75101196874403");
415 
416  /* Note about this:
417  * 149.57565307617187 == 0x4062B26BC0000000
418  * 149.57565307617188 == 0x4062B26BC0000000
419  *
420  * 0x4062B26BC0000000 == 149.575653076171875
421  * Both if we consider "round to nearest, ties to even" (which is what we use)
422  * or "round to nearest, ties away from zero":
423  * 75 => 80 => 8 for the last digit
424  *
425  * It acts the same way in PostgreSQL:
426  # Select '149.57565307617187'::float8, '149.575653076171875'::float8, '149.57565307617188'::float8;
427  float8 | float8 | float8
428  --------------------+--------------------+--------------------
429  149.57565307617188 | 149.57565307617188 | 149.57565307617188
430  (1 row)
431  */
432  assert_lwprint_equal(149.57565307617187, 15, "149.57565307617188");
433  assert_lwprint_equal(-149.57565307617187, 15, "-149.57565307617188");
434 
435  /* Shortest representation is used */
436  assert_lwprint_equal(7000109.9999999990686774253845214843750000000000, 8, "7000110");
437  assert_lwprint_equal(7000109.9999999990686774253845214843750000000000, 12, "7000109.999999999");
438 
439  /* SnapToGrid by itself is not enough to limit output decimals */
440  const double d = 526355.92112222222;
441  const double gridsize = 0.00001;
442  const double gridded = rint(d / gridsize) * gridsize; /* Formula from ptarray_grid_in_place */
443  assert_lwprint_equal(gridded, 15, "526355.9211200001");
444  assert_lwprint_equal(gridded, 5, "526355.92112");
445 
446  /* Test the change towards scientific notation */
447  assert_lwprint_equal(nextafter(OUT_MAX_DOUBLE, 0), OUT_MAX_DIGITS, "999999999999999.9");
448  assert_lwprint_equal(nextafter(-OUT_MAX_DOUBLE, 0), OUT_MAX_DIGITS, "-999999999999999.9");
449  assert_lwprint_equal(OUT_MAX_DOUBLE, OUT_MAX_DIGITS, "1e+15");
450  assert_lwprint_equal(-OUT_MAX_DOUBLE, OUT_MAX_DIGITS, "-1e+15");
451  assert_lwprint_equal(nextafter(OUT_MAX_DOUBLE, INFINITY), OUT_MAX_DIGITS, "1.0000000000000001e+15");
452  assert_lwprint_equal(nextafter(-OUT_MAX_DOUBLE, -INFINITY), OUT_MAX_DIGITS, "-1.0000000000000001e+15");
453 
454  assert_lwprint_equal(nextafter(OUT_MIN_DOUBLE, 0), OUT_MAX_DIGITS, "9.999999999999999e-9");
455  assert_lwprint_equal(nextafter(-OUT_MIN_DOUBLE, 0), OUT_MAX_DIGITS, "-9.999999999999999e-9");
456  assert_lwprint_equal(OUT_MIN_DOUBLE, OUT_MAX_DIGITS, "1e-8");
457  assert_lwprint_equal(-OUT_MIN_DOUBLE, OUT_MAX_DIGITS, "-1e-8");
458  assert_lwprint_equal(nextafter(OUT_MIN_DOUBLE, INFINITY), OUT_MAX_DIGITS, "0.000000010000000000000002");
459  assert_lwprint_equal(nextafter(-OUT_MIN_DOUBLE, -INFINITY), OUT_MAX_DIGITS, "-0.000000010000000000000002");
460 
461 
462  /* Big numbers that use scientific notation respect the precision parameter */
463  assert_lwprint_equal(9e+300, 0, "9e+300");
464  assert_lwprint_equal(9e+300, 15, "9e+300");
465  assert_lwprint_equal(-9e+300, 0, "-9e+300");
466  assert_lwprint_equal(-9e+300, 15, "-9e+300");
467  assert_lwprint_equal(9.000000000000001e+300, 0, "9e+300");
468  assert_lwprint_equal(9.000000000000001e+300, 15, "9.000000000000001e+300");
469  assert_lwprint_equal(-9.000000000000001e+300, 0, "-9e+300");
470  assert_lwprint_equal(-9.000000000000001e+300, 15, "-9.000000000000001e+300");
471 
472  assert_lwprint_equal(6917529027641081856.0, 17, "6.917529027641082e+18");
473  assert_lwprint_equal(6917529027641081856.0, 16, "6.917529027641082e+18");
474  assert_lwprint_equal(6917529027641081856.0, 15, "6.917529027641082e+18");
475  assert_lwprint_equal(6917529027641081856.0, 14, "6.91752902764108e+18");
476  assert_lwprint_equal(6917529027641081856.0, 13, "6.9175290276411e+18");
477  assert_lwprint_equal(6917529027641081856.0, 12, "6.917529027641e+18");
478  assert_lwprint_equal(6917529027641081856.0, 11, "6.91752902764e+18");
479  assert_lwprint_equal(6917529027641081856.0, 10, "6.9175290276e+18");
480  assert_lwprint_equal(6917529027641081856.0, 9, "6.917529028e+18");
481  assert_lwprint_equal(6917529027641081856.0, 8, "6.91752903e+18");
482  assert_lwprint_equal(6917529027641081856.0, 7, "6.917529e+18");
483  assert_lwprint_equal(6917529027641081856.0, 6, "6.917529e+18");
484  assert_lwprint_equal(6917529027641081856.0, 5, "6.91753e+18");
485  assert_lwprint_equal(6917529027641081856.0, 4, "6.9175e+18");
486  assert_lwprint_equal(6917529027641081856.0, 3, "6.918e+18");
487  assert_lwprint_equal(6917529027641081856.0, 2, "6.92e+18");
488  assert_lwprint_equal(6917529027641081856.0, 1, "6.9e+18");
489  assert_lwprint_equal(6917529027641081856.0, 0, "7e+18");
490 
491  /* Test special values (+-inf, NaNs) */
492  for (int i = precision_start; i < precision_end; i++)
493  {
494  assert_lwprint_equal(NAN, i, "NaN");
495  assert_lwprint_equal(INFINITY, i, "Infinity");
496  assert_lwprint_equal(-INFINITY, i, "-Infinity");
497  }
498 
499  /* Extremes */
500  assert_lwprint_equal(2.2250738585072014e-308, OUT_MAX_DIGITS, "2.2250738585072014e-308");
501  assert_lwprint_equal(1.7976931348623157e+308, OUT_MAX_DIGITS, "1.7976931348623157e+308"); /* Max */
502  assert_lwprint_equal(2.9802322387695312E-8, OUT_MAX_DIGITS, "0.000000029802322387695312"); /* Trailing zeros */
503 }
assert_lwprint_equal
#define assert_lwprint_equal(d, precision, expected)
Definition: cu_print.c:264
OUT_MAX_DIGITS
#define OUT_MAX_DIGITS
Definition: liblwgeom_internal.h:146
OUT_DEFAULT_DECIMAL_DIGITS
#define OUT_DEFAULT_DECIMAL_DIGITS
Definition: liblwgeom_internal.h:142
OUT_MAX_DOUBLE
#define OUT_MAX_DOUBLE
Definition: liblwgeom_internal.h:141
OUT_MIN_DOUBLE
#define OUT_MIN_DOUBLE
Definition: liblwgeom_internal.h:140
NAN
#define NAN
Definition: lwgeodetic.h:37

References assert_lwprint_equal, NAN, OUT_DEFAULT_DECIMAL_DIGITS, OUT_MAX_DIGITS, OUT_MAX_DOUBLE, and OUT_MIN_DOUBLE.

Referenced by print_suite_setup().

Here is the caller graph for this function: