# 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

### Algol 68

The following function computes the sum of the elements of the array passed to it. The type of the array elements is called NUM, which can be defined as any suitable integer or real type.

```MODE NUM = INT; # type of array element #

PROC sum = ([] NUM a) NUM :
BEGIN
NUM result := 0;
FOR i FROM LWB a TO UPB a DO
result +:= a[i]
OD;
result
END
```

For instance, the call

```sum((3, 4, 5, 6))
```

returns 18.

### C

Total of a series function. Terminate by using INT_MAX <highlightsyntax language="c"> //stdarg.h must be included for this type of function to be declared

1. 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;
```

} </highlightsyntax>

### C++

<highlightsyntax language="cpp">

1. include<numeric>

sum = std::accumulate(coll.begin(),coll.end(),0); </highlightsyntax>

### Common Lisp

<highlightsyntax language="lisp"> (reduce #'+ list) (reduce #'+ list :initial-value 0) ; improved version that also works with empty lists </highlightsyntax>

Another way:

<highlightsyntax language="lisp"> (apply #'+ list) </highlightsyntax>

### 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
```

### F#

<highlightsyntax language="fsharp"> Seq.sum container </highlightsyntax>

### Java

<highlightsyntax language="java122"> 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));

}
```

} </highlightsyntax>

### 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
```

### Perl

<HIGHLIGHTSYNTAX language="perl"> use List::Util qw(sum); sum @arr; sum 0, @arr; # improved version that also works with empty arrays </HIGHLIGHTSYNTAX>

### Python

A function that sums the values in a sequence is built into python, its name is 'sum'. <highlightsyntax language="python"> assert sum([1,2,3]) == 6 </highlightsyntax> A parallel to the ANSI C example given above is as follows: <highlightsyntax language="python"> import itertools def total(*values):

``` return sum(itertools.takewhile(sys.maxint.__cmp__, values))
```

assert total(1,2,3,sys.maxint) == 6 </highlightsyntax>

### Ruby

<highlightsyntax language="ruby"> class Array

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

end </highlightsyntax>

### Scheme

<highlightsyntax language="scheme"> (apply + list) </highlightsyntax>