Why am I unable to store my data in long data type?

Question

int power(int first,int second) {
    int counter1 = 0;
    long ret = 1;

    while (counter1 != second){
        ret *= first;
        counter1 += 1;
    }
    return ret;
}


int main(int argc,char **argv) {

    long one = atol(argv[1]);
    long two = atol(argv[2]);
    char word[30];
    long finally;

    printf("What is the operation? 'power','factorial' or 'recfactorial'\n");
    scanf("%20s",word);

    if (strcmp("power",word) == 0){
        finally = power(one,two);
        printf("%ld\n",finally);
        return 0;
    } 

}

This function is intended to do the "power of" operation like on the calculator, so if I write: ./a.out 5 3 it will give me 5 to the power of 3 and print out 125

The problem is, in cases where the numbers are like: ./a.out 20 10, 20 to the power of 10, I expect to see the result of: 1.024 x 10^13, but it instead outputs 797966336.

What is the cause of the current output I am getting?

Note: I assume that this has something to do with the atol() and long data types. Are these not big enough to store the information? If not, any idea how to make it run for bigger numbers?

Answer 1

Sure, your inputs are long, but your power function takes and returns int! Apparently, that's 32-bit on your system … so, on your system, 1.024×10¹³ is more than int can handle.

Make sure that you pick a type that's big enough for your data, and use it consistently. Even long may not be enough — check your system!

Answer 2

First and foremost, you need to change the return type and input parameter types of power() from int to long. Otherwise, on a system where long and int are having different size,

1. The input arguments may get truncated to int while you're passing long.

2. The returned value will be casted to int before returning, which can truncate the actual value.

After that, 1.024×10¹³ (10240000000000) cannot be held by an int or long (if 32 bits). You need to use a data type having more width, like long long.

Answer 3

one and two are long.

long one = atol(argv[1]);
long two = atol(argv[2]);

You call this function with them

int power(int first, int second);

But your function takes int, there is an implicit conversion here, and return int. So now, your long are int, that cause an undefined behaviour (see comments).

Answer 4

Quick answer:

The values of your power function get implicitly converted.

Change the function parameters to type other then int that can hold larger values, one possible type would be long.

• The input value gets type converted and truncated to match the parameters of your function.

• The result of the computation in the body of the function will be again converted to match the return type, in your case int: not able to handle the size of the values.

Note¹: as noted by the more experienced members, there is a machine-specific issue, which is that your int type is not handling the usual size int is supposed to handle.

---

^{1. To make the answer complete}

Answer 5

Code is mixing int, long and hoping for an answer the exceeds long range.

The answer is simply the result of trying to put 10 pounds of potatoes in a 5-pound sack.

---

... idea how to make it run for bigger numbers.

1. Use the widest integer available. Examples: uintmax_t, unsigned long long.

With C99 onward, normally the greatest representable integer will be UINTMAX_MAX.

#include <stdint.h>

uintmax_t power_a(long first, long second) {
  long counter1 = 0;
  uintmax_t ret = 1;

  while (counter1 != second){  // number of iterations could be in the billions
    ret *= first;
    counter1 += 1;
  }
  return ret;
}

But let us avoid problematic behavior with negative numbers and improve the efficiency of the calculation from liner to exponential.

// return x raised to the y power
uintmax_t pow_jululu(unsigned long x, unsigned long y) {
  uintmax_t z = 1;
  uintmax_t base = x;
  while (y) {   // max number of iterations would bit width: e.g. 64
    if (y & 1) {
      z *= base;
    }
    y >>= 1;
    base *= base;
  }
  return z;
}

int main(int argc,char **argv) {
    assert(argc >= 3);
    unsigned long one = strtoul(argv[1], 0, 10);
    unsigned long two = strtoul(argv[2], 0, 10);
    uintmax_t finally = pow_jululu(one,two);
    printf("%ju\n",finally);
    return 0;
}

This approach has limits too. 1) z *= base can mathematically overflow for calls like pow_jululu(2, 1000). 2) base*base may mathematically overflow in the uncommon situation where unsigned long is more than half the width of uintmax_t. 3) some other nuances too.

2. Resort to other types e.g.: long double, Arbitrary-precision arithmetic. This is likely beyond the scope of this simple task.

Answer 6

You could use a long long which is 8 bytes in length instead of the 4 byte length of long and int.

long long will provide you values between –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. This I think should just about cover every value you may encounter just now.