2 Replies Latest reply on Jul 23, 2012 5:22 AM by user_14586677

# multiplication ***int32

hai,

i couldn't acquire a uint32 multiplication with the following code  (psoc creator),  it calculates wrongly some value. whats my mistake.

#include

<device.h>

uint32

ball;

void

main()

{

ball=4*24*3600;

}

• ###### 1. Re: multiplication ***int32

The compiler by deafault will treat the constants as 'int' and then do a basic 'integer' multiplication, storing the result into the uint32.

You need to tell the compiler how to treat the constants, something like using an integer suffix like this:

ball = 4ul x 24ul x 3200ul;

• ###### 2. Re: multiplication ***int32

I learned something from this post, reference material -

## Integer constants

• Integer constants can be one of the different bases:

• a number starting with a digit from 1 to 9 followed only by digits from 0 to 9 is a decimal (base 10) constant, like `1` or `54321`
•
• if a number begins with '0x' or '0X' and is followed by digits from 0 to 9 and letters from a to f or from A to F, it is interpreted as a hexadecimal (base 16) constant, like `0xbeef` or `0XDEAD`
•
• if a number begins with 0 and is followed by digits from 0 to 7, it is interpreted as an octal (base 8) constant, like `07` (which is the same as `7`) or `0111` (which is NOT the same as `111`)
•
•
• integer constants in any of the three bases may be followed by an 'l' or 'L' to indicate a `long` constant, like `17l` or `0xFfL`
•
• in ANSI C, an integer constant may be followed by:

• a 'u' or 'U' to indicate an `unsigned` constant, like `33u`
•
• a 'ul' or 'UL' to indicate an `unsigned long` constant, like `32767ul`
•
•
• an integer constant takes on the minimum type necessary to be accurately represented, (possibly) starting as `int` and increasing from `long` to `unsigned long`

• octal and hexadecimal constants, and (in ANSI C) constants ending with a 'u' or 'U' may also be `unsigned` (which can hold larger values than `int` but may have fewer bytes than `long`)
•
•
• in ANSI C, 0 is always `unsigned` (perhaps to reduce ambiguity on machines with one's complement arithmetic)
•
• as an example, if an `int` is 16 bits wide and a `long` is 32 bits wide, the following ranges would apply:
`Range   Decimal  Octal/Hexadecimal 0   unsigned unsigned 1-32767   int  int 32768-65535  long  unsigned 65536-2147483647 long  long 2147483648-429497295 unsigned long unsigned long 429497296-?  ???  ???`
•

Regards, Dana.