Float to int conversion not working right in method using varargs

Question

I am trying to convert a floating point number to an integer, but it seems like the conversion is not working properly.

I am using the math library to calculate the power of 10 based on the number of varargs, where the first argument is the number of arguments followed by the varargs.

int charsToIntValue(int argc, ...) {
  int multiplier = (int) pow(10, argc - 1);
  va_list argp;
  va_start(argp, argc);
  Serial.println(multiplier);
  ...
  va_end(argp);
}

For some reason, multiplier is always stored as 1 less than the actual result. e.g. If charsToIntValue(4, 1, 2, 3, 4) is executed, the multiplier is stored as 999 rather than 1000. However, when it is printed as a float, it does show 1000.00. And whenever I change it to a constant ((int) pow(10, 3)) it works fine, returning 1000.

I've tired storing the value of argc into a local variable but that didn't seem to change anything.

Full project is here for context: https://github.com/Pyrodron/charger-destination-board

File in question is charger-destination-board.ino; lines 32 to 51

Answer 1

With some inspiration from timemage's comment, I decided in the long run to implement my own power function that takes two int arguments and returns an int. Rather than use the pow function in the <math.h> library which returns a double when I only need an int.

int power(int x, int y) {
  return y == 0 ? 1 : x * power(x, y - 1);
}

Now the program works as intended!

Answer 2

As explained by @chrisl in a comment, the issue is that pow() does not return an exact result, only an approximation. It works fine with compile-time constants because in this case it is evaluated at compile time, by the compiler, on you PC.

Simple solution: replace the cast to int with round():

int multiplier = round(pow(10, argc - 1));

This works, but is awfully inefficient, as pow() involves the computation of both an exponential and a logarithm, both very expensive on an AVR-based Arduino. The int-only function in your own answer is certainly better. However, it is generally advised to avoid recursion on low-memory Arduinos like the Uno. Prefer an iterative algorithm if you can.

Also, the complexity of you int-only function is O(y). There is a well-known algorithm for integer powers that goes like O(log(y)):

int power(int x, int y)
{
    int z = 1;  // Invariant: result = x^y * z
    while (y) {
        if (y & 1) z *= x;
        y >>= 1;
        x *= x;
    }
    return z;
}

Maybe I am nitpicking, as your y cannot go beyond 5 without overflowing the result...