fast_output.h File Reference

#include <cassert>
#include <cstdint>
#include <cstdio>

Include dependency graph for fast_output.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	strreverse (char *begin, char *end)
int	modp_dtoa (double value, char *str, int prec)
int	modp_uitoa10 (uint32_t value, char *str)
int	modp_itoa10 (int32_t value, char *str)

Function Documentation

modp_dtoa()

int modp_dtoa ( double  value, char *  str, int  prec  )

inline

Definition at line 56 of file fast_output.h.

                                                        {
  static const double pow10[] = {1,         10,        100,     1000,
                                 10000,     100000,    1000000, 10000000,
                                 100000000, 1000000000};
 
  /* Hacky test for NaN
   * under -fast-math this won't work, but then you also won't
   * have correct nan values anyways.  The alternative is
   * to link with libmath (bad) or hack IEEE double bits (bad)
   */
  if (!(value == value)) {
    str[0] = 'n';
    str[1] = 'a';
    str[2] = 'n';
    str[3] = '\0';
    assert(0);
    return 3;
  }
  /* if input is larger than thres_max, revert to exponential */
  const double thres_max = (double)(0x7FFFFFFF);
 
  double diff = 0.0;
  char* wstr = str;
 
  if (prec < 0) {
    prec = 0;
  } else if (prec > 9) {
    /* precision of >= 10 can lead to overflow errors */
    prec = 9;
  }
 
  /* we'll work in positive values and deal with the
     negative sign issue later */
  int neg = 0;
  if (value < 0) {
    neg = 1;
    value = -value;
  }
 
  int whole = (int)value;
  double tmp = (value - whole) * pow10[prec];
  uint32_t frac = (uint32_t)(tmp);
  diff = tmp - frac;
 
  if (diff > 0.5) {
    ++frac;
    /* handle rollover, e.g.  case 0.99 with prec 1 is 1.0  */
    if (frac >= pow10[prec]) {
      frac = 0;
      ++whole;
    }
  } else if (diff == 0.5 && ((frac == 0) || (frac & 1))) {
    /* if halfway, round up if odd, OR
       if last digit is 0.  That last part is strange */
    ++frac;
  }
 
  /* for very large numbers switch back to native sprintf for exponentials.
     anyone want to write code to replace this? */
  /*
     normal printf behavior is to print EVERY whole number digit
     which can be 100s of characters overflowing your buffers == bad
     */
  if (value > thres_max) {
    return sprintf(str, "%e", neg ? -value : value);
  }
 
  if (prec == 0) {
    diff = value - whole;
    if (diff > 0.5) {
      /* greater than 0.5, round up, e.g. 1.6 -> 2 */
      ++whole;
    } else if (diff == 0.5 && (whole & 1)) {
      /* exactly 0.5 and ODD, then round up */
      /* 1.5 -> 2, but 2.5 -> 2 */
      ++whole;
    }
  } else {
    int count = prec;
    // now do fractional part, as an unsigned number
    do {
      --count;
      *wstr++ = (char)(48 + (frac % 10));
    } while (frac /= 10);
    // add extra 0s
    while (count-- > 0) *wstr++ = '0';
    // add decimal
    *wstr++ = '.';
  }
 
  // do whole part
  // Take care of sign
  // Conversion. Number is reversed.
  do *wstr++ = (char)(48 + (whole % 10));
  while (whole /= 10);
  if (neg) {
    *wstr++ = '-';
  }
  //*wstr='\0';
  strreverse(str, wstr - 1);
  return wstr - str;
}

References strreverse().

Referenced by g2o::G2oSlamInterface::printVertex().

modp_itoa10()

int modp_itoa10 ( int32_t  value, char *  str  )

inline

Definition at line 170 of file fast_output.h.

                                                 {
  char* wstr = str;
  // Take care of sign
  unsigned int uvalue = (value < 0) ? -value : value;
  // Conversion. Number is reversed.
  do *wstr++ = (char)(48 + (uvalue % 10));
  while (uvalue /= 10);
  if (value < 0) *wstr++ = '-';
  *wstr = '\0';
 
  // Reverse string
  strreverse(str, wstr - 1);
  return wstr - str;
}

References strreverse().

Referenced by g2o::G2oSlamInterface::printVertex().

modp_uitoa10()

int modp_uitoa10 ( uint32_t  value, char *  str  )

inline

Definition at line 159 of file fast_output.h.

                                                   {
  char* wstr = str;
  // Conversion. Number is reversed.
  do *wstr++ = (char)(48 + (value % 10));
  while (value /= 10);
  //*wstr='\0';
  // Reverse string
  strreverse(str, wstr - 1);
  return wstr - str;
}

References strreverse().

strreverse()

void strreverse ( char *  begin, char *  end  )

inline

Definition at line 48 of file fast_output.h.

                                               {
  while (end > begin) {
    char aux = *end;
    *end-- = *begin;
    *begin++ = aux;
  }
}

Referenced by modp_dtoa(), modp_itoa10(), and modp_uitoa10().