integer-arithmetic

I am trying to get the sum of 1 + 2 + ... + 1000000000 , but I'm getting funny results in PHP and Node.js . PHP $sum = 0; for($i = 0; $i <= 1000000000 ; $i++) { $sum += $i; } printf("%s", number_format($sum, 0, "", "")); // 500000000067108992 Node.js var sum = 0; for (i = 0; i <= 1000000000; i++) { sum += i ; } console.log(sum); // 500000000067109000 The correct answer can be calculated using 1 + 2 + ... + n = n(n+1)/2 Correct answer = 500000000500000000 , so I decided to try another language. GO var sum , i int64 for i = 0 ; i <= 1000000000; i++ { sum += i } fmt.Println(sum) //

C language has signed and unsigned types like char and int. I am not sure, how it is implemented on assembly level, for example it seems to me that multiplication of signed and unsigned would bring different results, so do assembly do both unsigned and signed arithmetic or only one and this is in some way emulated for the different case? harold If you look at the various multiplication instructions of x86, looking only at 32bit variants and ignoring BMI2, you will find these: imul r/m32 (32x32->64 signed multiply) imul r32, r/m32 (32x32->32 multiply) * imul r32, r/m32, imm (32x32->32 multiply)

I have to store an integer value that is larger than the maximum value for the long datatype. How would I store and manipulate this value in memory? Please illustrate it through an example, if possible. Think about storing a numbers as sequences of decimal digits using a struct like this: struct num { int ndigits; char d[MAXDIGITS]; }; For example, the number 123456 could be initialized as struct num n = { 6, { 6, 5, 4, 3, 2, 1 } }; The reversed digit order turns out to be important for easy calculation. In particular, the place value of n.d[i] is n.d[i] * 10^i. Now, a few questions: How would

I have come across code from someone who appears to believe there is a problem subtracting an unsigned integer from another integer of the same type when the result would be negative. So that code like this would be incorrect even if it happens to work on most architectures. unsigned int To, Tf; To = getcounter(); while (1) { Tf = getcounter(); if ((Tf-To) >= TIME_LIMIT) { break; } } This is the only vaguely relevant quote from the C standard I could find. A computation involving unsigned operands can never overflow, because a result that cannot be represented by the resulting unsigned integer