Multiplication problem

My code works as follow:

Code:

---

#define h 12

int x = 0;
unsigned int y = 7

x += ( 5 - y) * h

---

I get x = -24 which it's ok

but if I replace the define statement for this:

Code:

---

#define h 12.5f

---

I dont get the expected result. I get -3276800. I would expect -25 whitch is a singed int result too.

any idea?

Is that the EXACT code you are using, or some sort of "a bit like this but not precisely"?

It sounds like you are printing a float as a integer.

--
Mats

You are trying to assign a floating point number to an integer. It won't work.

Quote:

---

Originally Posted by DaveH

You are trying to assign a floating point number to an integer. It won't work.

---

Of course it does. You may get a warning for converting float to int, but it "works" in the respect that it does roughly what you expect.

--
Mats

C99 section 6.3.1.3 states:

Quote:

---

When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged.

Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type.

(The rules describe arithmetic on the mathematical value, not the value of a given type of expression.)

---

Consequently, (5 - y) does not give you -2, but some unsigned integer that could be rather large. Now, when you multiply this by 12, there is an overflow, and then when you convert the result to signed int, the value happens to be what you expected.

The introduction of a float literal messed this accident up, and you got what you deserved, even though you did not expect it.

I have just create a sample program with codeblocks and mingw:

Code:

---

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

#define    h1  12
#define    h2  12.5f

int main()
{
    int x = 0;
    unsigned int y = 7;

    x += ( 5 - y) * h1;
    printf( "x = %d\n",x);

    x = 0; // Reset
    x += ( 5 - y) * h2;
    printf( "x = %d\n",x);

    return 0;
}

---

This is the output:

Code:

---

x = -24
x = -2147483648

---

I would expect a the int part of the float casted to int in the line "x += (5 - y) * h2" , but not. As you see, and if you compile the above, I dont get -25 :(

Quote:

---

Originally Posted by laserlight

C99 section 6.3.1.3 states:


Consequently, (5 - y) does not give you -2, but some unsigned integer that could be rather large. Now, when you multiply this by 12, there is an overflow, and then when you convert the result to signed int, the value happens to be what you expected.

The introduction of a float literal messed this accident up, and you got what you deserved, even though you did not expect it.

---

OK!!!, thanks, difficult to understand, I solved by casting the unsigned as follow:

x += ( 5 - (int) y) * h2;

I suggest you try this:

Code:

---

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

#define    h1  12
#define    h2  12.5f

int main()
{
    int x = 0;
    unsigned int y = 7;

    x += ( 5 - y) * h1;
    printf( "&#37;u\n", ( 5 - y) * h1);
    printf( "x = %d\n",x);

    x = 0; /* Reset */
    x += ( 5 - y) * h2;
    printf( "%f\n", ( 5 - y) * h2);
    printf( "x = %d\n",x);

    return 0;
}

---

What I have modified is to show you the value that will be added to x in each case. Check the value of INT_MAX. You probably will find that INT_MAX is smaller than the values to be added to x. Consequently:

Quote:

---

Originally Posted by C99 on conversion of an integer to signed integer

Otherwise, the new type is signed and the value cannot be represented in it; either the result is implementation-defined or an implementation-defined signal is raised.

---

Quote:

---

Originally Posted by C99 on conversion of a floating point number to integer

If the value of the integral part cannot be represented by the integer type, the behavior is undefined.

---

Quote:

---

Originally Posted by Kempelen

OK!!!, thanks, difficult to understand, I solved by casting the unsigned as follow:

x += ( 5 - (int) y) * h2;

---

Ohhh!!!, there is something I am not understanding or doing bad..... I modify the sample little program with that and it works, but I put that (int) cast in my original program and dont work

is that cast the solution or how did you modify the program to print the exact int?

The thing is that you're mixing integers and floats. This can pretty easily lead to unexpected results.
Try to keep the entire line as a single type and you'll be less susceptible to undefined behaviour.
If you have different types, try explicitly casting them to a correct type to keep the chain intact. The above modified code will yield the same result.
See code example below.

As someone once said to me: "The cardinal rule in using floating point numbers is: don't!" ;) Not mixing signed and unsigned is just as important as not mixing floats and ints. That is unless you know that's the right thing to do and you explicitly tell the compiler so by casting.

QuantumPete

Another example that yields correct result using the floating point:

Code:

---

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

#define    h1  12
#define    h2  12.5f

int main()
{
        int x = 0;
        unsigned int y = 7;
        float z;

        x += ( 5 - y) * h1;
        printf( "x = &#37;d\n",x);

        x = 0; // Reset
        x += ( 5 - y) * (int)h2;
        printf( "x = %d\n",x);

        z = 0; // Reset
        z += ((float)5 - (float)y) * h2;
        printf( "z = %f\n", z);

        return 0;
}

---

This code yields correct results (-24, -24, -25).

Quote:

---

This code yields correct results (-24, -24, -25).

---

It should yield a compile error since this is C ;)

I think Kempelen's ( 5 - (int) y) * h2 works, and Kempelen has stated as much. What does not work is the original program when this change is incorporated, but we cannot help debug something that we have no knowledge of.

Hmm, I wasn't aware C doesn't like type(x) casts instead of (type)x casts...
I always compile as C++/C, but I just tried the above code and it compiles in C (at least with VS).

Quote:

---

Hmm, I wasn't aware C doesn't like type(x) casts instead of (type)x casts...
I always compile as C++/C, but I just tried the above code and it compiles in C (at least with VS).

---

Must be a compiler extension. C99 does not provide for that syntax for casts.