Can a conversion from double to int be written in portable C

by

The answer to “Can a conversation from double to int be written in portable C” is clearly “yes“.

For example, you could sprintf the floating value to a string, do string-based inspection (i.e. by string-based comparison to max and min values you also sprintf’d), validation, rounding, etc and then sscanf the known-valid string for the final value.

In effect, you’d be moving toward an intermediate representation that’s (a) portable and (b) convenient. C strings are fine at portability, but not so convenient. If you can use external libraries, there are several that are convenient, but whose portability should be confirmed.

For example (which omits rounding):

#include <stdio.h>
#include <math.h>
#include <limits.h>
#include <string.h>

int convert(double inVal) {
    // basic range check - does anybody have an integer format with more than 300 bits?
    if (fabs(inVal) > 1.0E100) {
        printf("well out of range");
        return 1;
    }

    // load string buffer with input
    char buf[110];
    sprintf(buf, "%0105.0f", inVal);

    // do range check on strings
    if (inVal < 0) {
        char minVal[110];
        sprintf(minVal, "%0105d", INT_MIN);
        if (strcmp(buf, minVal) > 0) {
            printf("too small input: %f\n", inVal);
            return -1;  // needs better error signify
        }
    } else {
        char maxVal[110];
        sprintf(maxVal, "%0105d", INT_MAX);
        if (strcmp(maxVal, buf) < 0) {
            printf("too large input: %f\n", inVal);
            return -1;  // needs better error signify
        }
    }

    // do final conversion
    int result;
    sscanf(buf, "%d", &result);

    printf("input: %f result: %d\n", inVal, result);  // diagnostic

    return result;
}

int main()
{
    // test values    
    convert( 0.);
    convert( -123.5);
    convert( 123.5);

    convert( ((double)INT_MIN)-1);
    convert( ((double)INT_MIN));
    convert( ((double)INT_MIN)+1);
    convert( 2.0*((double)INT_MIN));
    convert( ((double)INT_MIN)/2);

    convert( ((double)INT_MAX)-1);
    convert( ((double)INT_MAX));
    convert( ((double)INT_MAX)+1);
    convert( 2.0*((double)INT_MAX));
    convert( ((double)INT_MAX)/2);

    return 0;
}

Which produces the expected conversions (see test cases at end above):

% gcc test.c ; ./a.out
input: 0.000000 result: 0
input: -123.500000 result: -124
input: 123.500000 result: 124
too small input: -2147483649.000000
input: -2147483648.000000 result: -2147483648
input: -2147483647.000000 result: -2147483647
too small input: -4294967296.000000
input: -1073741824.000000 result: -1073741824
input: 2147483646.000000 result: 2147483646
input: 2147483647.000000 result: 2147483647
too large input: 2147483648.000000
too large input: 4294967294.000000
input: 1073741823.500000 result: 1073741824

More Related Contents:

  1. Why does >= operator work as > operator in C when compared with 0.9 [duplicate]
  2. Correct format specifier for double in printf
  3. Effects of the extern keyword on C functions
  4. ‘float’ vs. ‘double’ precision
  5. Is an empty initializer list valid C code?
  6. What’s the use of suffix `f` on float value
  7. Simd matmul program gives different numerical results
  8. How to convert string to float?
  9. How to extract the decimal part from a floating point number in C?
  10. C: printf a float value
  11. C: Casting minimum 32-bit integer (-2147483648) to float gives positive number (2147483648.0)
  12. Are floating point operations in C associative?
  13. Convert double/float to string
  14. Ranges of floating point datatype in C?
  15. Precision in C floats
  16. My floating point number has extra digits when I print it
  17. Is there a function to round a float in C or do I need to write my own?
  18. Bitshift and integer promotion?
  19. C: How to wrap a float to the interval [-pi, pi)
  20. sin, cos, tan and rounding error
  21. What precisely does the %g printf specifier mean?
  22. List of platforms supported by the C standard
  23. Difference between scanf() and strtol() / strtod() in parsing numbers
  24. Is there a document describing how Clang handles excess floating-point precision?
  25. Why do you need an explicit `-lm` compiler option? [duplicate]
  26. Conditional tests in primality by trial division
  27. C fundamentals: double variable not equal to double expression?
  28. Does the C++ standard specify anything on the representation of floating point numbers?
  29. Integer overflow in C: standards and compilers
  30. How can floating point calculations be made deterministic?

Leave a Comment