dividing a small positive double-precision floating-point number by a large positive number giving me negative result

Question

I am writing a code in C which analyzes the constant factor of time complexity of all sorting techniques. I am including a statistical study of those constants. To do that I had to find the ratio of two positive double numbers. Surprisingly I am getting a negative result. Could anybody help me understand what I am missing here?

I started digging in wiki https://en.wikipedia.org/wiki/C_data_types and this https://www.geeksforgeeks.org/data-types-in-c/, but that does not seem to have the answer I am looking for.

#include <stdio.h>

int main(void) {
    // your code goes here
    int i=1500;
    double j=9265.49;
    double result=(double)j/((double)(i*i*i*i));
    printf("%lf",result);
    return 0;
}

The result is -0.000007 which is clearly wrong.

`i*i*i*i` - this is what is "giving negative result". Have you heard of integer overflow? — Eugene Sh., Jan 25 '19 at 18:12
Debug tip: Using `"%e"`, `"%a"` and `"%g"` are all more informative than `"%lf"`. — chux - Reinstate Monica, Jan 25 '19 at 18:17
1500 ** 4 = 5062500000000 = 0x4 9A B4 83 A1 00, hence this will only work if `int` is a 64-bit integer, otherwise you'll get an overflow. The remainder is then converted to `double`. — Stefan Becker, Jan 25 '19 at 18:20

chux - Reinstate Monica · Answer 1 · 2019-01-25T19:15:07.717

int overflow

i*i*i*i is int math and int overflow¹ which is undefined behavior (UB). @Eugene Sh.

In OP's case, i*i*i*i --> became -1266441984 or so.

Avoid overflow in the multiplication. Perform the multiplication with wider math.

int main(void) {
  int i = 1500;
  double j = 9265.49;
  // double result=(double)j/((double)(i*i*i*i));
  double result = (double) j / ((double) i * i * i * i);
  printf("%e", result);
  return 0;
}

Output

1.830220e-09

See There are reasons not to use 1000 * 1000 * 1000 for additional insights about code such as i*i*i*i.

¹ When INT_MAX < 5062500000000 as with 32-bit int.

score 1 · Answer 2 · answered Jan 25 '19 at 18:27

Integer overflow:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main(int argc, char *argv[]) {
  int      i   = 1500;
  int32_t  i32 = 1500;
  uint32_t u32 = 1500;

  printf("i  : %lf\n", (double)(i*i*i*i));
  printf("i32: %lf\n", (double)(i32*i32*i32*i32));
  printf("u32: %lf\n", (double)(u32*u32*u32*u32));

  long int li  = 1500;
  int64_t  i64 = 1500;
  uint64_t u64 = 1500;

  printf("li : %lf\n", (double)(li*li*li*li));
  printf("i64: %lf\n", (double)(i64*i64*i64*i64));
  printf("u64: %lf\n", (double)(u64*u64*u64*u64));

  return(0);
}

Output on my Linux x86_64 with GCC 8:

$ ./dummy 
i  : -1266441984.000000
i32: -1266441984.000000
u32: 3028525312.000000
li : 5062500000000.000000
i64: 5062500000000.000000
u64: 5062500000000.000000

dividing a small positive double-precision floating-point number by a large positive number giving me negative result

2 Answers2