[udunits] Less pernickety version of ut_compare() ?

• To: udunits@xxxxxxxxxxxxxxxx
• Subject: [udunits] Less pernickety version of ut_compare() ?
• From: PIGUET Bruno <bruno.piguet@xxxxxxxx>
• Date: Tue, 11 Aug 2015 14:34:59 +0200 (CEST)

Hi,

    I found the ut_compare() function, as currently existing the the udunits2 
library,  to be too strict for my needs.

    In particular, for some units, the comparison between the original unit and 
a back-and-forth transformation to text expression fails.
    In other words :  for some values of unit, ut_compare(unit, 
(ut_parse(ut_format(unit))) != 0.

    I know that a decimal textual representation of a real number cannot be 
exact, but I believe that we can safely assume that two units whose relative 
difference is less than 10^-8 or 10^-10 are identical.
    So, I wrote my own, more tolerant, ut_compare function (see attached source 
code).

     My questions are :
                 - is this pernickety behaviour intended, or did someone just 
wrote the test "a==b" for floating-point values instead of the usual 
approximate test ? 
                 - Am I the only one interested in a more lenient version of 
ut_compare() ? Would it be a good idea to add a ut_tolerant_compare() function 
to the udunits2 library ? 

Regards,

Bruno.

-- 
Bruno Piguet 
Météo-France 
Équipe GMEI/TRAMM 
CNRM/GAME, UMR3589 CNRS/Météo-France 
Fixe : +33 561079659 
Fax : +33 561079627 
Postal : 42 Av. G. Coriolis 
31057 Toulouse CEDEX 1 

/**
 * Demonstration of the strict behaviour of ut_compare(), (for some values
 * of unit, ut_compare(unit, (ut_parse(ut_format(unit))) != 0), and 
 * of a more lenient version.
 * 
 * compile with :
 *  gcc -O  pb_compare.c -ludunits2  -o pb_compare
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#include <udunits2/udunits2.h>

static ut_system *unitSystem;


int
my_ut_compare_pragmatic (const ut_unit * unit1, const ut_unit * unit2)
{
  int CodRet;
  ut_unit *ratio_ut_unit;
  double ratio_double;
  char buf[120];
  char *endptr;

  CodRet = ut_compare (unit1, unit2);
  if (CodRet == 0)
    return CodRet;

  /* "This function returns a non-zero value if conversion is possible;
   *  otherwise, 0 is returned" */
  CodRet = ut_are_convertible (unit1, unit2);
  /* if conversion impossible, exit */
  if (CodRet == 0)
    return -5;

  /* let's see if conversion ratio is close to 1 */
  ratio_ut_unit = ut_divide (unit1, unit2);
  if (ratio_ut_unit == NULL)
    return -6;

  /* Don't know how tho get the ration from an ut_unit variable.
   * So, let's format it and parse the resulting string */
  CodRet = ut_format (ratio_ut_unit, buf, sizeof (buf), UT_ASCII);
  ut_free (ratio_ut_unit);
  ratio_ut_unit = NULL;
  if ((CodRet < 0) || (CodRet >= (int) sizeof (buf)))
    {
      return -7;
    }

  /* the end must be " 1" (meaning dimensionless) */
  if ((strlen (buf) > 2) && (!strcmp (buf + strlen (buf) - 2, " 1")))
    {
      buf[strlen (buf) - 2] = 0;
      ratio_double = strtod (buf, &endptr);
      if ((*endptr == 0) && (fabs (1.0 - ratio_double) < 1.0e-8))
        {
          /* Approximately equal --> OK ! */
          return 0;
        }
    }
  return -8;
}


void
test_back_forth (const char *unit_str)
{
  ut_unit *unit_1, *unit_2;
  char buf[120];
  int len, cmp_cod;

  unit_1 = ut_parse (unitSystem, unit_str, UT_ASCII);
  if (unit_1 == NULL)
    {
      fprintf (stderr, "Error %d parsing : %s\n", ut_get_status (), unit_str);
      return;
    }

  len = ut_format (unit_1, buf, sizeof (buf), UT_ASCII);
  if ((len < 0) || (len >= (int) sizeof (buf)))
    {
      fprintf (stderr, "Error %d writing unit\n", ut_get_status ());
      ut_free (unit_1);
      return;
    }
  fprintf (stdout, "%s formatted as : %s\n", unit_str, buf);

  unit_2 = ut_parse (unitSystem, buf, UT_ASCII);
  if (unit_2 == NULL)
    {
      fprintf (stderr, "Error %d parsing : %s\n", ut_get_status (), buf);
      ut_free (unit_1);
      return;
    }

  cmp_cod = ut_compare (unit_1, unit_2);
  fprintf (stdout, "    ut_compare(%s, %s) = %d\n", unit_str, buf, cmp_cod);
  cmp_cod = my_ut_compare_pragmatic (unit_1, unit_2);
  fprintf (stdout, "    my_ut_compare(%s, %s) = %d\n", unit_str, buf,
           cmp_cod);

  ut_free (unit_1);
  ut_free (unit_2);
}

int
main (int argc, char *argv[])
{
  const char *unit_tab[] = { "degree",
    "kt",
    "ft/min",
    "mm/h",
    "l/min"
  };

  unsigned long nb_unit = sizeof (unit_str) / sizeof (*unit_str);
  unsigned long i;

  unitSystem = ut_read_xml (NULL);
  if (unitSystem == NULL)
    return 1;

  for (i = 0; i < nb_unit; i++)
    test_back_forth (unit_tab[i]);

  ut_free_system (unitSystem);
  return 0;
}

• Follow-Ups:
  • Re: [udunits] Less pernickety version of ut_compare() ?
    • From: Steve Emmerson