Truncation In C++

Question

Today I was trying to write a program that would sum up the integer input by user. For example if user input 683 it would return 6 + 8 + 3 = 17.

But I encounter some weird problem in my code

The Code :

#include

using namespace std;
int computeSum(int num);
int computeInteger(int num, int position);

int main()
{
    int num;
    int sum;
    int total;
    cin >> num;

    total = computeSum(num);

    cout << total;
    return 0;
}

int computeSum(int num) 
{
    int position = 10;
    int temp = num;
    double total = 0;
    bool finish = false;

    while(!finish)
    {
        total = total + computeInteger(num, position);

        if(num/ position == 0)
            break;
        position *= 10;
    }

    return total;
}

int computeInteger(int num, int position)
{
    double subtract1 = (double) num / position; //if num = 683 and position = 10 ,     this will get 68.3
    int subtract2 = num / position; //if num = 683 and position = 10 , this will get 68
    double solution = subtract1 - subtract2; //take 68.3 - 68 = 0.3
    return (int)(solution * 10); // return 0.3 * 10 = 3 , but instead of getting 3 this program return 0.3 * 10 = 2
 }

The Question

In the above code, when I input 683, for the function computeInteger, instead of getting the last digit 3 I get 2 as a return value. This is very weird as I thought truncation would only remove the floating part and not doing any round up or down.When I test the code cout << (int)(0.3 * 10) I did get 3 , but not in the code above. It makes me confuse.

Why float computing while the input and output are integers? — masoud, Sep 06 '13 at 08:35
yes, @JonathanPotter is right. you have to round to nearest integer before you cast to int. Add an answer! — Adriano Repetti, Sep 06 '13 at 08:37
@GrijeshChauhan: it's the reason of getting inaccurate results. He should read about float computing in computer world. — masoud, Sep 06 '13 at 08:39
http://stackoverflow.com/questions/12963024/how-to-get-short-value-using-double-function — adripanico, Sep 06 '13 at 08:47
I think you can do something more simple that the functions are you using there.. — dan8912, Sep 06 '13 at 08:52
Well if i change double to float , 911 will not yield 11 but 10 — caramel1995, Sep 06 '13 at 09:20
Ok, you're right you need to change the computeInteger function.. — dan8912, Sep 06 '13 at 10:05

score 5 · Answer 1 · edited May 23 '17 at 11:54

double subtract1 = (double) num / position; //if num = 683 and position = 10 , this will get 68.3

This is not entirely true, the 0.3 is not the rational number in base 2, those it will be very close to the 0.3 but less as the number is always rounded down, to narrow the mistake you can cast it to float or long float but this is not a case, as in your example it will always be 0.29, if you want to understand what really happens you must read about the number representation in the computers, it is very well described here:

http://en.wikipedia.org/wiki/Computer_number_format

The error you encountered is well known mistake also described in the wiki page:

http://en.wikipedia.org/wiki/Round-off_error

And Stack link:

What is a simple example of floating point/rounding error?

score 5 · Answer 2 · edited Apr 12 '17 at 07:31

5

In floating point, 68.3 isn't 68.3, but is more like 68.299999997. Read about floating point rounding errors.

edited Apr 12 '17 at 07:31

Community

1
1

answered Sep 06 '13 at 08:41

Jonathan Potter

36,172
4
64
79

+1 Then (if you don't want to change the logic you use to isolate digits) just **round the number to nearest integer** before you cast to int: `(int)round(solution * 10)`. Of course you may use one of the others rounding functions too... – Adriano Repetti Sep 06 '13 at 08:49

score 1 · Answer 3 · answered Sep 06 '13 at 08:52

1

To get floating point out of the way:

inline int computeInteger(int num, int position) {
    return (num / (position / 10)) % 10;
}

answered Sep 06 '13 at 08:52

score 1 · Answer 4 · answered Sep 06 '13 at 15:10

There is no need to use floating-point for this calculation. Replace computeSum and and computeInteger with:

int computeSum(int num)
{
    int sum = 0;
    for (; num; num /= 10)
        sum += num % 10;
    return sum;
}

Note: Your code permits negative values for num. If you want to support those, you will need to add additional code.

score 0 · Answer 5 · edited Sep 06 '13 at 08:51

0

Yes, you're right you get 2. Let me explain why: if the num = 683 I'll show you what the debugger says for the values from your comuteInteger function:

double subtract1 = (double) num / position;  // substract1=68.299999999999997
int subtract2 = num / position; // subtract2 = 68
return (int)(solution * 10); // 2.99999999999997 casted to int will be 2

This is for the first step..

edited Sep 06 '13 at 08:51

Yu Hao

119,891
44
235
294

answered Sep 06 '13 at 08:48

dan8912

31
1
7

score 0 · Answer 6 · answered Sep 06 '13 at 10:13

0

If I'll have to do something similar I'll create a recursive function like below:

int total(int num){
if(num == 0){
    return 0;
}else{
    return num%10 + total(num/10);
}
}

answered Sep 06 '13 at 10:13

dan8912

31
1
7

score 0 · Answer 7 · answered Sep 06 '13 at 13:27

0

The usual approach for picking off digits is to use n % 10 to get the value of the lowest digit then n /= 10 to remove the lowest digit. Repeat until done.

answered Sep 06 '13 at 13:27

Pete Becker

74,985
8
76
165

Truncation In C++

The Code :

The Question

7 Answers7