Sum of 1 to 1000000000 in different programming languages

int64_t is just a typdef'd long long in linux and osx:

typedef long long int int64_t;

I think I might be doing it wrong, because I didn't do any looping. I'm a bit too lazy and impatient for that, who wants to spend their afternoon adding all those numbers up even with a computer.

  [joe24pack@staropramen ~]$ python
  Python 2.6.6 (r266:84292, May  1 2012, 13:52:17) 
  [GCC 4.4.6 20110731 (Red Hat 4.4.6-3)] on linux2
  Type "help", "copyright", "credits" or "license" for more information.
  >>> def gauss(x):
  ...   return (x+1)*(x/2)
  ... 
  >>> gauss(10)
  55
  >>> gauss(1000000000)
  500000000500000000
  >>>

> Why [+/- 52 bit] ?

Floating point numbers ("floats") work like the scientific notation (e.g. "12 * 10^-3" ). They have an mantissa and an exponent. Double precision (64 bit) floats have a 52 bits integer mantissa, a sign bit, and 11 bits used to represent the exponent, or to encode NaN values ("Not a Number"), like the result of "0/0".

> Why [only floats in JavaScript] ?

The language was supposed to have a low barrier of entry, and having a single number type was thought to be less complex to explain, even though floats have some weird corner cases regarding rounding when you don't understand how they are implemented. Beyond the loss of precision in large numbers, some rationals that have a finite representation in base 10 have an infinite representation in base 2.

For example, 0.2 in base 10 is 0.00110011... in base 2. It is thus rounded to 52 bits. Who says rounding says rounding error.

Here's a Node.JS session that demonstrate the behaviour:

    > e = 0.2
    0.2
    > e = e + 0.2
    0.4
    > e = e + 0.2
    0.6000000000000001
    > e == 0.6
    false
    > e = e + 0.2
    0.8
    > e = e + 0.2
    1
    > e == 1
    true

Python 2.7 (Mid 2012 Macbook Pro, 2.5 GHz i5, 8GB, not using SSD)

sum + xrange (consumes ~20MB virtual memory):

    $ time python2.7 -c "print sum(xrange(1,1000000001))"
    500000000500000000
    python2.7 -c "print sum(xrange(1,1000000001))"  11.06s user 0.02s system 99% cpu 11.089 total

reduce + xrange (consumes ~20MB virtual memory):

    $ time python2.7 -c "print reduce(lambda a, b: a + b, xrange(1,1000000001))"
    500000000500000000
    python2.7 -c "print reduce(lambda a, b: a + b, xrange(1,1000000001))"  128.74s user 0.13s system 94% cpu 2:16.51 total

My machine swapping like crazy for more than an hour when I try using range(). I suspect it hasn't even finished allocating the list when I kill the process after it consumes >30GB virtual memory.

    $ time python2.7 -c "print sum(range(1,1000000001))"

Fun fact: in R, sum(1:1E07) will throw a warning; you have to use sum(as.numeric(1:1E07)) instead, which will indeed give the correct answer.