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

From CodeCodex

(Haskell)
 
(13 intermediate revisions by 8 users not shown)
Line 12: Line 12:
 
The following function computes the sum of the elements of the array passed to it. The type of the array elements is called <TT>NUM</TT>, which can be defined as any suitable integer or real type.
 
The following function computes the sum of the elements of the array passed to it. The type of the array elements is called <TT>NUM</TT>, which can be defined as any suitable integer or real type.
  
<pre>MODE NUM = INT; # type of array element #
+
<pre>
 +
MODE NUM = INT; # type of array element #
  
 
PROC sum = ([] NUM a) NUM :
 
PROC sum = ([] NUM a) NUM :
Line 26: Line 27:
 
For instance, the call
 
For instance, the call
  
<pre>sum((3, 4, 5, 6))
+
<pre>
 +
sum((3, 4, 5, 6))
 
</pre>
 
</pre>
 
returns 18.
 
returns 18.
  
 +
===Assembly===
 +
INT_MAX = 2147483647.
 +
<pre>
 +
sum proc
 +
mov ecx,DWORD PTR [esp]
 +
add esp,4
 +
xor eax,eax
 +
sum_loop1:
 +
add eax,DWORD PTR [esp]
 +
add esp,4
 +
cmp DWORD PTR [esp],2147483647
 +
jne sum_loop1
 +
mov DWORD PTR [esp],ecx
 +
ret
 +
sum endp
 +
</pre>
  
 
===C===
 
===C===
Total of a series function.  Terminate by using INT_MAX
+
<pre class="c">
<highlightsyntax language="c">
+
int total( int numbers[], int size ) {
//stdarg.h must be included for this type of function to be declared
+
   int sum = 0, i;
#include <stdarg.h>
+
   for ( i = 0 ; i < size ; i++ )
 
+
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
+
       sum += numbers[i];
      i = va_arg( marker, int);  //Gets the next argument
+
 
   }
 
   }
  va_end( marker );              // Resets the list
 
 
   return sum;
 
   return sum;
 
}
 
}
</highlightsyntax>
+
</pre>
  
 
===C++===
 
===C++===
<highlightsyntax language="cpp">
+
<pre class="cpp">
 
#include<numeric>
 
#include<numeric>
  
 
sum = std::accumulate(coll.begin(),coll.end(),0);
 
sum = std::accumulate(coll.begin(),coll.end(),0);
</highlightsyntax>
+
</pre>
  
 
===Common Lisp===
 
===Common Lisp===
<highlightsyntax language="lisp">
+
<pre class="lisp">
 
(reduce #'+ list)
 
(reduce #'+ list)
 
(reduce #'+ list :initial-value 0) ; improved version that also works with empty lists
 
(reduce #'+ list :initial-value 0) ; improved version that also works with empty lists
</highlightsyntax>
+
</pre>
  
 
Another way:
 
Another way:
  
<highlightsyntax language="lisp">
+
<pre class="lisp">
 
(apply #'+ list)
 
(apply #'+ list)
</highlightsyntax>
+
</pre>
  
===Assembly===
+
===Erlang===
INT_MAX = 2147483647.
+
 
<pre>
 
<pre>
sum proc
+
lists:sum(List).
mov ecx,DWORD PTR [esp]
+
add esp,4
+
xor eax,eax
+
sum_loop1:
+
add eax,DWORD PTR [esp]
+
add esp,4
+
cmp DWORD PTR [esp],2147483647
+
jne sum_loop1
+
mov DWORD PTR [esp],ecx
+
ret
+
sum endp
+
 
</pre>
 
</pre>
  
===F#===
+
===Excel===
 +
<pre>
 +
=SUM([cells])
 +
</pre>
  
<highlightsyntax language="fsharp">
+
===F#===
 +
<pre class="fsharp">
 
Seq.sum container
 
Seq.sum container
</highlightsyntax>
+
</pre>
  
 
===Haskell===
 
===Haskell===
<highlightsyntax language="haskell">
+
<pre class="haskell">
 
sum container
 
sum container
</highlightsyntax>
+
</pre>
 +
For example:
 +
<pre>
 +
Prelude> sum [1, 2, 3, 4]
 +
10
 +
</pre>
  
 
===Java===
 
===Java===
<highlightsyntax language="java122">
+
<pre class="java">
 
import java.util.*;
 
import java.util.*;
  
Line 117: Line 123:
 
     }
 
     }
 
}
 
}
</highlightsyntax>
+
</pre>
  
 
===OCaml===
 
===OCaml===
Line 132: Line 138:
  
 
===Perl===
 
===Perl===
<HIGHLIGHTSYNTAX language="perl">
+
<pre class="perl">
 
use List::Util qw(sum);
 
use List::Util qw(sum);
 
sum @arr;
 
sum @arr;
 
sum 0, @arr; # improved version that also works with empty arrays
 
sum 0, @arr; # improved version that also works with empty arrays
</HIGHLIGHTSYNTAX>
+
</pre>
  
 
===Python===
 
===Python===
 
A function that sums the values in a sequence is built into python, its name is 'sum'.
 
A function that sums the values in a sequence is built into python, its name is 'sum'.
<highlightsyntax language="python">
+
<pre class="python">
 
assert sum([1,2,3]) == 6
 
assert sum([1,2,3]) == 6
</highlightsyntax>
+
</pre>
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===
 
===Ruby===
<highlightsyntax language="ruby">
+
<pre class="ruby">
 
class Array
 
class Array
   def sum;     inject(0) { |s, v| s += v }; end
+
   def sum
 +
     inject { |s, v| s += v }
 +
  end
 
end
 
end
</highlightsyntax>
+
</pre>
 +
Or more concisely,
 +
<pre class="ruby">
 +
class Array
 +
  def sum
 +
    reduce(:+)
 +
  end
 +
end
 +
</pre>
  
 
===Scheme===
 
===Scheme===
<highlightsyntax language="scheme">
+
<pre class="scheme">
 
(apply + list)
 
(apply + list)
</highlightsyntax>
+
</pre>
 +
 
 +
===Tcl===
 +
<pre class="tcl">
 +
proc sum list {expr ([join $list +])}
 +
</pre>
  
 
===Zsh===
 
===Zsh===
 
<pre>
 
<pre>
array=(1 2 3 4 5)
+
zsum() {
sum=(${(j:+:)array})  
+
local -a array
</pre>
+
array=(1 2 3 4 5)
<pre>
+
(( sum=${(j:+:)array} ))
# Mathematical evaluation
+
return sum
print $((sum))
+
}
 
</pre>
 
</pre>
result: 15
 
  
 
[[Category:Math]]
 
[[Category:Math]]
 
[[Category:Arrays]]
 
[[Category:Arrays]]
  
[[Category:C]]
+
[[Category:Algol 68]]
[[Category:C plus plus]]
+
 
[[Category:Assembly]]
 
[[Category:Assembly]]
 +
[[Category:C]]
 +
[[Category:C++]]
 +
[[Category:Common Lisp]]
 +
[[Category:Erlang]]
 +
[[Category:Excel]]
 +
[[Category:F sharp]]
 
[[Category:Haskell]]
 
[[Category:Haskell]]
 
[[Category:Java]]
 
[[Category:Java]]
 +
[[Category:Objective Caml]]
 
[[Category:Perl]]
 
[[Category:Perl]]
 
[[Category:Python]]
 
[[Category:Python]]
[[Category:Objective Caml]]
 
 
[[Category:Ruby]]
 
[[Category:Ruby]]
[[Category:Algol 68]]
 
[[Category:Common Lisp]]
 
 
[[Category:Scheme]]
 
[[Category:Scheme]]
[[Category:F sharp]]
+
[[Category:Tcl]]
 
[[Category:Zsh]]
 
[[Category:Zsh]]

Latest revision as of 15:50, 10 August 2012

Related content:

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

See also[edit]

Implementations[edit]

Algol 68[edit]

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.

Assembly[edit]

INT_MAX = 2147483647.

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

C[edit]

int total( int numbers[], int size ) {
   int sum = 0, i;
   for ( i = 0 ; i < size ; i++ )
   {
      sum += numbers[i];
   }
   return sum;
}

C++[edit]

#include<numeric>

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

Common Lisp[edit]

(reduce #'+ list)
(reduce #'+ list :initial-value 0) ; improved version that also works with empty lists

Another way:

(apply #'+ list)

Erlang[edit]

lists:sum(List).

Excel[edit]

=SUM([cells])

F#[edit]

Seq.sum container

Haskell[edit]

sum container

For example:

Prelude> sum [1, 2, 3, 4]
10

Java[edit]

import java.util.*;

public class Total {

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

    public static void main(String[] args) {

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

OCaml[edit]

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[edit]

use List::Util qw(sum);
sum @arr;
sum 0, @arr; # improved version that also works with empty arrays

Python[edit]

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

assert sum([1,2,3]) == 6

Ruby[edit]

class Array
  def sum
    inject { |s, v| s += v }
  end
end

Or more concisely,

class Array
  def sum
    reduce(:+)
  end
end

Scheme[edit]

(apply + list)

Tcl[edit]

proc sum list {expr ([join $list +])}

Zsh[edit]

zsum() {
	local -a array
	array=(1 2 3 4 5)
	(( sum=${(j:+:)array} ))
	return sum
}