# Difference between revisions of "Calculate the sum over a container"

 Related content:

This code demonstrates how to calculate the sum of a container (most often an array or similar structure).

## Implementations

### C

Total of a series function. Terminate by using INT_MAX

```//stdarg.h must be included for this type of function to be declared
#include <stdarg.h>

int total( int first, ... ) {
int count = 0, sum = 0, i = first;
va_list marker;

va_start( marker, first );     /* Initialize variable arguments. */
while( i != INT_MAX )
{
sum += i;                   //increases the sum
i = va_arg( marker, int);   //Gets the next argument
}
va_end( marker );              // Resets the list
return sum;
}
```

### C++

```#include<numeric>

sum = accumulate(coll.begin(),coll.end(),0);
```

### Common Lisp

```(reduce #'+ list)
```

### Assembly

INT_MAX = 2147483647.

```sum proc
mov ecx,DWORD PTR [esp]
xor eax,eax
sum_loop1:
cmp DWORD PTR [esp],2147483647
jne sum_loop1
mov DWORD PTR [esp],ecx
ret
sum endp
```

```sum container
```

### Java

```import java.util.*;

public class Total {

public static int total(int... values) {
int total = 0;
for (int i : values) total += i;
}

public static void main(String[] args) {

System.out.println("Total: %d: ", total(1,2,4,40));

}
}
```

### OCaml

Summing is a special case of folding the addition operator starting with zero:

```# let sum = List.fold_left ( + ) 0;;
val sum : int list -> int = <fun>
```

For example:

```# sum [1; 2; 4; 40];;
- : int = 47
```

### Python

A function that sums the values in a sequence is built into python, its name is 'sum'.

```if __name__ == '__main__':
assert sum([1,2,3]) == 6
```

A parallel to the ANSI C example given above is as follows:

```import itertools
def total(*values):
return sum(itertools.takewhile(sys.maxint.__cmp__, values))

if __name__ == '__main__':
assert total(1,2,3,sys.maxint) == 6
```

### Ruby

```class Array
def sum;     inject(0) { |s, v| s += v }; end
end
```