Averages/Arithmetic mean

From Rosetta Code
(Redirected from Mean)
Jump to: navigation, search
Task
Averages/Arithmetic mean
You are encouraged to solve this task according to the task description, using any language you may know.
Write a program to find the mean (arithmetic average) of a numeric vector. In case of a zero-length input, since the mean of an empty set of numbers is ill-defined, the program may choose to behave in any way it deems appropriate, though if the programming language has an established convention for conveying math errors or undefined values, it's preferable to follow it.

See also: Median, Mode

Contents

[edit] 6502 Assembly

Called as a subroutine (i.e., JSR ArithmeticMean), this calculates the integer average of up to 255 8-bit unsigned integers. The address of the beginning of the list of integers is in the memory location ArrayPtr and the number of integers is in the memory location NumberInts. The arithmetic mean is returned in the memory location ArithMean.

ArithmeticMean:		PHA
TYA
PHA ;push accumulator and Y register onto stack
 
 
LDA #0
STA Temp
STA Temp+1 ;temporary 16-bit storage for total
 
LDY NumberInts
BEQ Done ;if NumberInts = 0 then return an average of zero
 
DEY ;start with NumberInts-1
AddLoop: LDA (ArrayPtr),Y
CLC
ADC Temp
STA Temp
LDA Temp+1
ADC #0
STA Temp+1
DEY
CPY #255
BNE AddLoop
 
LDY #-1
DivideLoop: LDA Temp
SEC
SBC NumberInts
STA Temp
LDA Temp+1
SBC #0
STA Temp+1
INY
BCS DivideLoop
 
Done: STY ArithMean ;store result here
PLA ;restore accumulator and Y register from stack
TAY
PLA
RTS ;return from routine

[edit] ACL2

(defun mean-r (xs)
(if (endp xs)
(mv 0 0)
(mv-let (m j)
(mean-r (rest xs))
(mv (+ (first xs) m) (+ j 1)))))
 
(defun mean (xs)
(if (endp xs)
0
(mv-let (n d)
(mean-r xs)
(/ n d))))

[edit] ActionScript

function mean(vector:Vector.<Number>):Number
{
var sum:Number = 0;
for(var i:uint = 0; i < vector.length; i++)
sum += vector[i];
return vector.length == 0 ? 0 : sum / vector.length;
}

[edit] Ada

This example shows how to pass a zero length vector as well as a larger vector.

with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.Text_IO; use Ada.Text_IO;
 
procedure Mean_Main is
type Vector is array(Positive range <>) of Float;
function Mean(Item : Vector) return Float is
Sum : Float := 0.0;
Result : Float := 0.0;
begin
for I in Item'range loop
Sum := Sum + Item(I);
end loop;
if Item'Length > 0 then
Result := Sum / Float(Item'Length);
end if;
return Result;
end Mean;
A : Vector := (3.0, 1.0, 4.0, 1.0, 5.0, 9.0);
begin
Put(Item => Mean(A), Fore => 1, Exp => 0);
New_Line;
-- test for zero length vector
Put(Item => Mean(A(1..0)), Fore => 1, Exp => 0);
New_Line;
end Mean_Main;

Output:

3.83333
0.00000

[edit] ALGOL 68

Translation of: C
Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - note that some necessary LONG REAL operators are missing from ELLA's library.
PROC mean = (REF[]REAL p)REAL:
# Calculates the mean of qty REALs beginning at p. #
IF LWB p > UPB p THEN 0.0
ELSE
REAL total := 0.0;
FOR i FROM LWB p TO UPB p DO total +:= p[i] OD;
total / (UPB p - LWB p + 1)
FI;
 
main:(
[6]REAL test := (1.0, 2.0, 5.0, -5.0, 9.5, 3.14159);
print((mean(test),new line))
)

[edit] AmigaE

Because of the way Amiga E handles floating point numbers, the passed list/vector must contain all explicitly floating point values (e.g., you need to write "1.0", not "1")

PROC mean(l:PTR TO LONG)
DEF m, i, ll
ll := ListLen(l)
IF ll = 0 THEN RETURN 0.0
m := 0.0
FOR i := 0 TO ll-1 DO m := !m + l[i]
m := !m / (ll!)
ENDPROC m
 
PROC main()
DEF s[20] : STRING
WriteF('mean \s\n',
RealF(s,mean([1.0, 2.0, 3.0, 4.0, 5.0]), 2))
ENDPROC

[edit] AutoHotkey

i = 10
Loop, % i {
Random, v, -3.141592, 3.141592
list .= v "`n"
sum += v
}
MsgBox, % i ? list "`nmean: " sum/i:0

[edit] AWK

# work around a gawk bug in the length extended use:
# so this is a more non-gawk compliant way to get
# how many elements are in an array
function elength(v)
{
l=0
for(el in v) l++
return l
}
 
function mean(v)
{
if (elength(v) < 1) { return 0 }
sum = 0
for(i=0; i < elength(v); i++) {
sum += v[i]
}
return sum/elength(v)
}
 
BEGIN {
# fill a vector with random numbers
for(i=0; i < 10; i++) {
vett[i] = rand()*10
}
print mean(vett)
}

[edit] APL

Works with: APL2
      X←3 1 4 1 5 9
(+/X)÷⍴X
3.833333333

[edit] Babel

((main {
(2 3 5 7 11 13 17 19 23)
avg !
 %d nl <<})
 
(avg {
dup
<- sum ! ->
len
cudiv })
 
(sum { <- 0 -> {+} each }))

The above program will output 11. Note that Babel does not support floating point. An arbitrary-precision math library is planned for version 2.0.

[edit] BASIC

Works with: QBasic

Assume the numbers are in an array named "nums".

mean = 0
sum = 0;
FOR i = LBOUND(nums) TO UBOUND(nums)
sum = sum + nums(i);
NEXT i
size = UBOUND(nums) - LBOUND(nums) + 1
PRINT "The mean is: ";
IF size <> 0 THEN
PRINT (sum / size)
ELSE
PRINT 0
END IF

[edit] BBC BASIC

To calculate the mean of an array:

 
REM specific functions for the array/vector types
 
REM Byte Array
DEF FN_Mean_Arithmetic&(n&())
= SUM(n&()) / (DIM(n&(),1)+1)
 
REM Integer Array
DEF FN_Mean_Arithmetic%(n%())
= SUM(n%()) / (DIM(n%(),1)+1)
 
REM Float 40 array
DEF FN_Mean_Arithmetic(n())
= SUM(n()) / (DIM(n(),1)+1)
 
REM A String array
DEF FN_Mean_Arithmetic$(n$())
LOCAL I%, S%, sum, Q%
S% = DIM(n$(),1)
FOR I% = 0 TO S%
Q% = TRUE
ON ERROR LOCAL Q% = FALSE
IF Q% sum += EVAL(n$(I%))
NEXT
= sum / (S%+1)
 
REM Float 64 array
DEF FN_Mean_Arithmetic#(n#())
= SUM(n#()) / (DIM(n#(),1)+1)
 

Michael Hutton 14:02, 29 May 2011 (UTC)

[edit] bc

Uses the current scale for calculating the mean.

define m(a[], n) {
auto i, s
 
for (i = 0; i < n; i++) {
s += a[i]
}
return(s / n)
}

[edit] Befunge

The first input is the length of the vector. If a length of 0 is entered, the result is equal to 0/0.

&:0\:!v!:-1<
@./\$_\&+\^

[edit] Bracmat

Here are two solutions. The first uses a while loop, the second scans the input by backtracking.

 
(mean1=
sum length n
. 0:?sum:?length
& whl
' ( !arg:%?n ?arg
& 1+!length:?length
& !n+!sum:?sum
)
& !sum*!length^-1
);
 
(mean2=
sum length n
. 0:?sum:?length
&  !arg
 :  ?
( #%@?n
& 1+!length:?length
& !n+!sum:?sum
& ~
)
 ?
| !sum*!length^-1
);
 

To test with a list of all numbers 1 .. 999999:

 
( :?test
& 1000000:?Length
& whl'(!Length+-1:?Length:>0&!Length !test:?test)
& out$mean1$!test
& out$mean2$!test
)

[edit] Brainf***

This example is under development. It was marked thus on 02/12/2009. Please help complete the example.

This code is an infinite loop if the average isn't a whole number. I don't have the time, can someone fix it to work with all numbers, not just single-digit numbers?

>,[-<+>>+<],<[->-<]>[-->+<]>.


[edit] Brat

mean = { list |
true? list.empty?, 0, { list.reduce(0, :+) / list.length }
}
 
p mean 1.to 10 #Prints 5.5

[edit] Burlesque

 
blsq ) {1 2 2.718 3 3.142}av
2.372
blsq ) {}av
NaN
 

[edit] C

Compute mean of a double array of given length. If length is zero, does whatever 0/0 does (usually means returning NaN).

#include <stdio.h>
 
double mean(double *v, int len)
{
double sum = 0;
int i;
for (i = 0; i < len; i++)
sum += v[i];
return sum / len;
}
 
int main(void)
{
double v[] = {1, 2, 2.718, 3, 3.142};
int i, len;
for (len = 5; len >= 0; len--) {
printf("mean[");
for (i = 0; i < len; i++)
printf(i ? ", %g" : "%g", v[i]);
printf("] = %g\n", mean(v, len));
}
 
return 0;
}
Output:

mean[1, 2, 2.718, 3, 3.142] = 2.372 mean[1, 2, 2.718, 3] = 2.1795 mean[1, 2, 2.718] = 1.906 mean[1, 2] = 1.5 mean[1] = 1 mean[] = -nan

[edit] C#

using System;
using System.Linq;
 
class Program
{
static void Main()
{
Console.WriteLine(new[] { 1, 2, 3 }.Average());
}
}

Alternative version (not using the built-in function):

using System;
 
class Program
{
static void Main(string[] args)
{
double average = 0;
 
double[] numArray = { 1, 2, 3, 4, 5 };
average = Average(numArray);
 
Console.WriteLine(average); // Output is 3
 
// Alternative use
average = Average(1, 2, 3, 4, 5);
 
Console.WriteLine(average); // Output is still 3
Console.ReadLine();
}
 
static double Average(params double[] nums)
{
double d = 0;
 
foreach (double num in nums)
d += num;
return d / nums.Length;
}
}

[edit] C++

Library: STL
#include <vector>
 
double mean(const std::vector<double>& numbers)
{
if (numbers.size() == 0)
return 0;
 
double sum = 0;
for (std::vector<double>::iterator i = numbers.begin(); i != numbers.end(); i++)
sum += *i;
return sum / numbers.size();
}

Shorter (and more idiomatic) version:

#include <vector>
#include <algorithm>
 
double mean(const std::vector<double>& numbers)
{
if (numbers.empty())
return 0;
return std::accumulate(numbers.begin(), numbers.end(), 0.0) / numbers.size();
}

Idiomatic version templated on any kind of iterator:

#include <iterator>
#include <algorithm>
 
template <typename Iterator>
double mean(Iterator begin, Iterator end)
{
if (begin == end)
return 0;
return std::accumulate(begin, end, 0.0) / std::distance(begin, end);
}

[edit] Chef

Mean.
 
Chef has no way to detect EOF, so rather than interpreting
some arbitrary number as meaning "end of input", this program
expects the first input to be the sample size. Pass in the samples
themselves as the other inputs. For example, if you wanted to
compute the mean of 10, 100, 47, you could pass in 3, 10, 100, and
47. To test the "zero-length vector" case, you need to pass in 0.
 
Ingredients.
0 g Sample Size
0 g Counter
0 g Current Sample
 
Method.
Take Sample Size from refrigerator.
Put Sample Size into mixing bowl.
Fold Counter into mixing bowl.
Put Current Sample into mixing bowl.
Loop Counter.
Take Current Sample from refrigerator.
Add Current Sample into mixing bowl.
Endloop Counter until looped.
If Sample Size.
Divide Sample Size into mixing bowl.
Put Counter into 2nd mixing bowl.
Fold Sample Size into 2nd mixing bowl.
Endif until ifed.
Pour contents of mixing bowl into baking dish.
 
Serves 1.

[edit] Clojure

Returns a ratio:

(defn mean [sq]
(if (empty? sq)
0
(/ (reduce + sq) (count sq))))

Returns a float:

(defn mean [sq]
(if (empty? sq)
0
(float (/ (reduce + sq) (count sq)))))

[edit] COBOL

Intrinsic function:

FUNCTION MEAN(some-table (ALL))

Sample implementation:

       IDENTIFICATION DIVISION.
PROGRAM-ID. find-mean.
 
DATA DIVISION.
LOCAL-STORAGE SECTION.
01 i PIC 9(4).
 
01 summ USAGE FLOAT-LONG.
 
LINKAGE SECTION.
01 nums-area.
03 nums-len PIC 9(4).
03 nums USAGE FLOAT-LONG
OCCURS 0 TO 1000 TIMES
DEPENDING ON nums-len.
 
01 result USAGE FLOAT-LONG.
 
PROCEDURE DIVISION USING nums-area, result.
IF nums-len = 0
MOVE 0 TO result
GOBACK
END-IF
 
DIVIDE FUNCTION SUM(nums (ALL)) BY nums-len GIVING result
 
GOBACK
.

[edit] Cobra

 
class Rosetta
def mean(ns as List<of number>) as number
if ns.count == 0
return 0
else
sum = 0.0
for n in ns
sum += n
return sum / ns.count
 
def main
print "mean of [[]] is [.mean(List<of number>())]"
print "mean of [[1,2,3,4]] is [.mean([1.0,2.0,3.0,4.0])]"
 

Output:

mean of [] is 0
mean of [1, 2, 3, 4] is 2.5

[edit] CoffeeScript

 
mean = (array) ->
return 0 if array.length is 0
sum = array.reduce (s,i,0) -> s += i
sum / array.length
 
 
alert mean [1]
 

[edit] Common Lisp

With Reduce

(defun mean (&rest sequence)
(if (null sequence)
nil
(/ (reduce #'+ sequence) (length sequence))))

With Loop

(defun mean (list)
(unless (null list)
(/ (loop for i in list sum i)
(length list))))

[edit] D

[edit] Imperative Version

real mean(Range)(Range r) pure nothrow @nogc {
real sum = 0.0;
int count;
 
foreach (item; r) {
sum += item;
count++;
}
 
if (count == 0)
return 0.0;
else
return sum / count;
}
 
void main() {
import std.stdio;
 
int[] data;
writeln("Mean: ", data.mean);
data = [3, 1, 4, 1, 5, 9];
writeln("Mean: ", data.mean);
}
Output:
mean: 0
mean: 3.83333

[edit] More Functional Version

import std.stdio, std.algorithm, std.range;
 
real mean(Range)(Range r) pure nothrow @nogc {
return r.sum / max(1.0L, r.count);
}
 
void main() {
writeln("Mean: ", (int[]).init.mean);
writeln("Mean: ", [3, 1, 4, 1, 5, 9].mean);
}
Output:
Mean: 0
Mean: 3.83333

[edit] More Precise Version

A (naive?) version that tries to minimize precision loss (but already the sum algorithm applied to a random access range of floating point values uses a more precise summing strategy):

import std.stdio, std.conv, std.algorithm, std.math, std.traits;
 
CommonType!(T, real) mean(T)(T[] n ...) if (isNumeric!T) {
alias E = CommonType!(T, real);
auto num = n.dup;
num.schwartzSort!(abs, "a > b");
return num.map!(to!E).sum(0.0L) / max(1, num.length);
}
 
void main() {
writefln("%8.5f", mean((int[]).init));
writefln("%8.5f", mean( 0, 3, 1, 4, 1, 5, 9, 0));
writefln("%8.5f", mean([-1e20, 3, 1, 4, 1, 5, 9, 1e20]));
}
Output:
 0.00000
 2.87500
 2.87500

[edit] Dart

num mean(List<num> l) => l.reduce((num p, num n) => p + n) / l.length;
 
void main(){
print(mean([1,2,3,4,5,6,7]));
}
Output:
4.0

[edit] Delphi

program AveragesArithmeticMean;
 
{$APPTYPE CONSOLE}
 
uses Types;
 
function ArithmeticMean(aArray: TDoubleDynArray): Double;
var
lValue: Double;
begin
Result := 0;
 
for lValue in aArray do
Result := Result + lValue;
if Result > 0 then
Result := Result / Length(aArray);
end;
 
begin
Writeln(Mean(TDoubleDynArray.Create()));
Writeln(Mean(TDoubleDynArray.Create(1,2,3,4,5)));
end.

[edit] E

Slightly generalized to support any object that allows iteration.

def meanOrZero(numbers) {
var count := 0
var sum := 0
for x in numbers {
sum += x
count += 1
}
return sum / 1.max(count)
}

[edit] Elena

#define system.
#define system'routines.
 
// --- Sum ---
 
#class MeanAction : BasePattern
{
#field theValue.
#field theCount.
 
#constructor new
[
theValue := Real new.
theCount := Integer new.
]
 
#method evaluate : aValue
[
theCount += 1.
 
theValue += aValue.
]
 
#method number = theValue / theCount.
}
 
// --- Program ---
 
#symbol program =
[
console writeLine:(MeanAction new foreach:(1, 2, 3, 4, 5, 6, 7, 8) number).
].

[edit] Elixir

 
defmodule RC do
def mean(list), do: Enum.sum(list) / Enum.count(list)
end
 

[edit] Emacs Lisp

  (defun mean (lst)
(/ (float (apply '+ lst)) (length lst)))
(mean '(1 2 3 4))

[edit] Erlang

mean([]) -> 0;
mean(L) -> lists:sum(L)/erlang:length(L).

[edit] Euphoria

function mean(sequence s)
atom sum
if length(s) = 0 then
return 0
else
sum = 0
for i = 1 to length(s) do
sum += s[i]
end for
return sum/length(s)
end if
end function
 
sequence test
test = {1.0, 2.0, 5.0, -5.0, 9.5, 3.14159}
? mean(test)

[edit] Excel

Assuming the values are entered in the A column, type into any cell which will not be part of the list:

=AVERAGE(A1:A10)

Assuming 10 values will be entered, alternatively, you can just type:

=AVERAGE(

and then select the start and end cells, not necessarily in the same row or column.

The output for the first expression, for the set {x | 1 <= x <= 10, x E N} is

1	5,5
2	
3	
4	
5	
6	
7	
8	
9	
10	

[edit] Factor

USING: math math.statistics ;
 
: arithmetic-mean ( seq -- n )
[ 0 ] [ mean ] if-empty ;

Tests:

( scratchpad ) { 2 3 5 } arithmetic-mean >float
3.333333333333333

[edit] Fantom

 
class Main
{
static Float average (Float[] nums)
{
if (nums.size == 0) return 0.0f
Float sum := 0f
nums.each |num| { sum += num }
return sum / nums.size.toFloat
}
 
public static Void main ()
{
[[,], [1f], [1f,2f,3f,4f]].each |Float[] i|
{
echo ("Average of $i is: " + average(i))
}
}
}
 

[edit] Fish

!vl0=?vl1=?vl&!
v< +<>0n; >n;
>l1)?^&,n;

Must be called with the values pre-populated on the stack, which can be done in the fish.py interpreter with the -v switch:

fish.py mean.fish -v 10 100 47 207.4

which generates:

91.1

[edit] Forth

: fmean ( addr n -- f )
0e
dup 0= if 2drop exit then
tuck floats bounds do
i f@ f+
1 floats +loop
0 d>f f/ ;
 
create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,
test 6 fmean f. \ 3.83333333333333

[edit] Fortran

In ISO Fortran 90 or later, use the SUM intrinsic, the SIZE intrinsic and the MAX intrinsic (to avoid divide by zero):

real, target, dimension(100) :: a = (/ (i, i=1, 100) /)
real, dimension(5,20) :: b = reshape( a, (/ 5,20 /) )
real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array
real :: mean, zmean, bmean
real, dimension(20) :: colmeans
real, dimension(5) :: rowmeans
 
mean = sum(a)/size(a) ! SUM of A's elements divided by SIZE of A
mean = sum(a)/max(size(a),1) ! Same result, but safer code
! MAX of SIZE and 1 prevents divide by zero if SIZE == 0 (zero-length array)
 
zmean = sum(p)/max(size(p),1) ! Here the safety check pays off. Since P is a zero-length array,
! expression becomes "0 / MAX( 0, 1 ) -> 0 / 1 -> 0", rather than "0 / 0 -> NaN"
 
bmean = sum(b)/max(size(b),1) ! multidimensional SUM over multidimensional SIZE
 
rowmeans = sum(b,1)/max(size(b,2),1) ! SUM elements in each row (dimension 1)
! dividing by the length of the row, which is the number of columns (SIZE of dimension 2)
colmeans = sum(b,2)/max(size(b,1),1) ! SUM elements in each column (dimension 2)
! dividing by the length of the column, which is the number of rows (SIZE of dimension 1)

[edit] Frink

The following works on arrays or sets. If the collection is empty, this returns the special value undef.

 
mean[x] := length[x] > 0 ? sum[x] / length[x] : undef
 

[edit] F#

The following computes the running mean using a tail-recursive approach. If we just sum all the values then divide by the number of values then we will suffer from overflow problems for large lists. See wikipedia about the moving average computation.

let avg (a:float) (v:float) n =
a + (1. / ((float n) + 1.)) * (v - a)
 
let mean_series list =
let a, _ = List.fold_left (fun (a, n) h -> avg a (float h) n, n + 1) (0., 0) list in
a

Checking this:

 > mean_series [1; 8; 2; 8; 1; 7; 1; 8; 2; 7; 3; 6; 1; 8; 100] ;;
val it : float = 10.86666667
> mean_series [] ;;
val it : float = 0.0

We can also make do with the built-in List.average function:

List.average [4;1;7;5;8;4;5;2;1;5;2;5]

[edit] GAP

Mean := function(v)
local n;
n := Length(v);
if n = 0 then
return 0;
else
return Sum(v)/n;
fi;
end;
 
Mean([3, 1, 4, 1, 5, 9]);
# 23/6

[edit] GEORGE

R (n) P ;
0
1, n rep (i)
R P +
]
n div
P

Output:

 7.000000000000000      
 1.500000000000000E+0001
 1.300000000000000E+0001
 8.000000000000000      
 2.500000000000000E+0001
 7.400000000000000E+0001
 3.100000000000000E+0001
 2.900000000000000E+0001
 1.700000000000000E+0001
 4.300000000000000E+0001
 2.620000000000000E+0001

[edit] Go

A little more elaborate that the task requires. The function "mean" fulfills the task of "a program to find the mean." As a Go idiom, it returns an ok value of true if result m is valid. An ok value of false means the input "vector" (a Go slice) was empty. The fancy accuracy preserving algorithm is a little more than was called more. The program main is a test program demonstrating the ok idiom and several data cases.

package main
 
import (
"fmt"
"math"
)
 
func mean(v []float64) (m float64, ok bool) {
if len(v) == 0 {
return
}
// an algorithm that attempts to retain accuracy
// with widely different values.
var parts []float64
for _, x := range v {
var i int
for _, p := range parts {
sum := p + x
var err float64
switch ax, ap := math.Abs(x), math.Abs(p); {
case ax < ap:
err = x - (sum - p)
case ap < ax:
err = p - (sum - x)
}
if err != 0 {
parts[i] = err
i++
}
x = sum
}
parts = append(parts[:i], x)
}
var sum float64
for _, x := range parts {
sum += x
}
return sum / float64(len(v)), true
}
 
func main() {
for _, v := range [][]float64{
[]float64{}, // mean returns ok = false
[]float64{math.Inf(1), math.Inf(1)}, // answer is +Inf
 
// answer is NaN, and mean returns ok = true, indicating NaN
// is the correct result
[]float64{math.Inf(1), math.Inf(-1)},
 
[]float64{3, 1, 4, 1, 5, 9},
 
// large magnitude numbers cancel. answer is mean of small numbers.
[]float64{1e20, 3, 1, 4, 1, 5, 9, -1e20},
 
[]float64{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11},
[]float64{10, 20, 30, 40, 50, -100, 4.7, -11e2},
} {
fmt.Println("Vector:", v)
if m, ok := mean(v); ok {
fmt.Printf("Mean of %d numbers is %g\n\n", len(v), m)
} else {
fmt.Println("Mean undefined\n")
}
}
}
Output:
Vector: []
Mean undefined

Vector: [+Inf +Inf]
Mean of 2 numbers is +Inf

Vector: [+Inf -Inf]
Mean of 2 numbers is NaN

Vector: [3 1 4 1 5 9]
Mean of 6 numbers is 3.8333333333333335

Vector: [1e+20 3 1 4 1 5 9 -1e+20]
Mean of 8 numbers is 2.875

Vector: [10 9 8 7 6 5 4 3 2 1 0 0 0 0 0.11]
Mean of 15 numbers is 3.674

Vector: [10 20 30 40 50 -100 4.7 -1100]
Mean of 8 numbers is -130.6625

[edit] Groovy

def avg = { list -> list == [] ? 0 : list.sum() / list.size() }

Test Program:

println avg(0..9)
println avg([2,2,2,4,2])
println avg ([])

Output:

4.5
2.4
0

[edit] Haskell

This function works if the element type is an instance of Fractional:

mean :: (Fractional a) => [a] -> a
mean [] = 0
mean xs = sum xs / Data.List.genericLength xs

But some types, e.g. integers, are not Fractional; the following function works for all Real types:

meanReals :: (Real a, Fractional b) => [a] -> b
meanReals = mean . map realToFrac

If you want to avoid keeping the list in memory and traversing it twice:

{-# LANGUAGE BangPatterns #-}
import Data.List (foldl')
mean :: (Real n, Fractional m) => [n] -> m
mean xs = let (s,l) = foldl'
f (0, 0) xs in realToFrac s / l
where f (!s,!l) x = (s+x,l+1)

[edit] HicEst

REAL :: vec(100)               ! no zero-length arrays in HicEst
 
vec = $ - 1/2 ! 0.5 ... 99.5
mean = SUM(vec) / LEN(vec) ! 50
END

[edit] Icon and Unicon

procedure main(args)
every (s := 0) +:= !args
write((real(s)/(0 ~= *args)) | 0)
end

Sample outputs:

->am 1 2 3 4 5 6 7
4.0
->am
0
->

[edit] IDL

If truly only the mean is wanted, one could use

x = [3,1,4,1,5,9]
print,mean(x)

But mean() is just a thin wrapper returning the zeroth element of moment() :

print,moment(x)
; ==>
3.83333 8.96667 0.580037 -1.25081

which are mean, variance, skewness and kurtosis.

There are no zero-length vectors in IDL. Every variable has at least one value or otherwise it is <Undefined>.

[edit] J

mean=: +/ % #

That is, sum divided by the number of items. The verb also works on higher-ranked arrays. For example:

   mean 3 1 4 1 5 9
3.83333
mean $0 NB. $0 is a zero-length vector
0
x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers
mean x
0.58243 0.402948 0.477066 0.511155

The computation can also be written as a loop. It is shown here for comparison only and is highly non-preferred compared to the version above.

mean1=: 3 : 0
z=. 0
for_i. i.#y do. z=. z+i{y end.
z % #y
)
mean1 3 1 4 1 5 9
3.83333
mean1 $0
0
mean1 x
0.58243 0.402948 0.477066 0.511155

[edit] Java

Works with: Java version 1.5+

Assume the numbers are in a double array called "nums".

...
double sum = 0;
for(double i : nums){
sum += i;
}
System.out.println("The mean is: " + ((nums.length != 0) ? (sum / nums.length) : 0));
...

[edit] JavaScript

function mean(array)
{
var sum = 0, i;
for (i = 0; i < array.length; i++)
{
sum += array[i];
}
return array.length ? sum / array.length : 0;
}
 
alert( mean( [1,2,3,4,5] ) ); // 3
Library: Functional
function mean(a)
{
return a.length ? Functional.reduce('+', 0, a) / a.length : 0;
}

[edit] jq

The mean of an array of numbers can be computed by simply writing

add/length

This definition raises an error condition if the array is empty, so it may make sense to define mean as follows, null being jq's null value:

def mean: if length == 0 then null 
else add/length
end;

[edit] Julia

Julia's built-in mean function accepts AbstractArrays (vector, matrix, etc.)

julia> mean([1,2,3])
2.0
julia> mean(1:10)
5.5
julia> mean([])
ERROR: mean of empty collection undefined: []

[edit] K

  mean: {(+/x)%#x}
mean 1 2 3 5 7
3.6
mean@!0 / empty array
0.0

[edit] LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
LabVIEW Averages Arithmetic mean.png

[edit] Lasso

define average(a::array) => {
not #a->size ? return 0
local(x = 0.0)
with i in #a do => { #x += #i }
return #x / #a->size
}
 
average(array(1,2,5,17,7.4)) //6.48

[edit]

to average :l
if empty? :l [output 0]
output quotient apply "sum :l count :l
end
print average [1 2 3 4]  ; 2.5

[edit] Liberty BASIC

total=17
dim nums(total)
for i = 1 to total
nums(i)=i-1
next
 
for j = 1 to total
sum=sum+nums(j)
next
if total=0 then mean=0 else mean=sum/total
print "Arithmetic mean: ";mean
 

[edit] Logtalk

Logtalk's standard library provides an arithmetic average predicate but we ignore it here. Representing a vector using a list:

 
:- object(averages).
 
:- public(arithmetic/2).
 
% fails for empty vectors
arithmetic([X| Xs], Mean) :-
sum_and_count([X| Xs], 0, Sum, 0, Count),
Mean is Sum / Count.
 
% use accumulators to make the predicate tail-recursive
sum_and_count([], Sum, Sum, Count, Count).
sum_and_count([X| Xs], Sum0, Sum, Count0, Count) :-
Sum1 is Sum0 + X,
Count1 is Count0 + 1,
sum_and_count(Xs, Sum1, Sum, Count1, Count).
 
:- end_object.
 

Sample output:

 
| ?- averages::arithmetic([1,2,3,4,5,6,7,8,9,10], Mean).
Mean = 5.5
yes
 

[edit] LSL

integer MAX_ELEMENTS = 10;
integer MAX_VALUE = 100;
default {
state_entry() {
list lst = [];
integer x = 0;
for(x=0 ; x<MAX_ELEMENTS ; x++) {
lst += llFrand(MAX_VALUE);
}
llOwnerSay("lst=["+llList2CSV(lst)+"]");
llOwnerSay("Geometric Mean: "+(string)llListStatistics(LIST_STAT_GEOMETRIC_MEAN, lst));
llOwnerSay(" Max: "+(string)llListStatistics(LIST_STAT_MAX, lst));
llOwnerSay(" Mean: "+(string)llListStatistics(LIST_STAT_MEAN, lst));
llOwnerSay(" Median: "+(string)llListStatistics(LIST_STAT_MEDIAN, lst));
llOwnerSay(" Min: "+(string)llListStatistics(LIST_STAT_MIN, lst));
llOwnerSay(" Num Count: "+(string)llListStatistics(LIST_STAT_NUM_COUNT, lst));
llOwnerSay(" Range: "+(string)llListStatistics(LIST_STAT_RANGE, lst));
llOwnerSay(" Std Dev: "+(string)llListStatistics(LIST_STAT_STD_DEV, lst));
llOwnerSay(" Sum: "+(string)llListStatistics(LIST_STAT_SUM, lst));
llOwnerSay(" Sum Squares: "+(string)llListStatistics(LIST_STAT_SUM_SQUARES, lst));
}
}

Output:

lst=[23.815209, 85.890704, 10.811144, 31.522696, 54.619416, 12.211729, 42.964463, 87.367889, 7.106129, 18.711078]
Geometric Mean:    27.325070
           Max:    87.367889
          Mean:    37.502046
        Median:    27.668953
           Min:     7.106129
     Num Count:    10.000000
         Range:    80.261761
       Std Dev:    29.819840
           Sum:   375.020458
   Sum Squares: 22067.040048

[edit] Lua

function mean (numlist)
if type(numlist) ~= 'table' then return numlist end
num = 0
table.foreach(numlist,function(i,v) num=num+v end)
return num / #numlist
end
 
print (mean({3,1,4,1,5,9}))

[edit] Lucid

avg(x)
where
sum = first(x) fby sum + next(x);
n = 1 fby n + 1;
avg = sum / n;
end

[edit] M4

M4 handle only integers, so in order to have a slightly better math for the mean, we must pass to the mean macro integers multiplied by 100. The macro rmean could embed the macro fmean and extractdec directly, but it is a little bit clearer to keep them separated.

define(`extractdec', `ifelse(eval(`$1%100 < 10'),1,`0',`')eval($1%100)')dnl
define(`fmean', `eval(`($2/$1)/100').extractdec(eval(`$2/$1'))')dnl
define(`mean', `rmean(`$#', $@)')dnl
define(`rmean', `ifelse(`$3', `', `fmean($1,$2)',dnl
`rmean($1, eval($2+$3), shift(shift(shift($@))))')')dnl
mean(0,100,200,300,400,500,600,700,800,900,1000)

[edit] Maple

This version accepts any indexable structure, including numeric arrays. We use a call to the "environment variable" (dynamically scoped global) "Normalizer" to provide normalization of symbolic expressions. This can be set by the caller to adjust the strength of normalization desired.

 
mean := proc( a :: indexable )
local i;
Normalizer( add( i, i in a ) / numelems( a ) )
end proc:
 

For example:

 
> mean( { 1/2, 2/3, 3/4, 4/5, 5/6 } ); # set
71
---
100
 
> mean( [ a, 2, c, 2.3, e ] ); # list
0.8600000000 + a/5 + c/5 + e/5
 
> mean( Array( [ 1, sin( s ), 3, exp( I*t ), 5 ] ) ); # array
9/5 + 1/5 sin(s) + 1/5 exp(t I)
 
> mean( [ sin(s)^2, cos(s)^2 ] );
2 2
1/2 sin(s) + 1/2 cos(s)
 
> Normalizer := simplify: # use a stronger normalizer than the default
> mean( [ sin(s)^2, cos(s)^2 ] );
1/2
 
> mean([]); # empty argument causes an exception to be raised.
Error, (in mean) numeric exception: division by zero
 

A slightly different design computes the mean of all its arguments, instead of requiring a single container argument. This seems a little more Maple-like for a general purpose utility.

mean := () -> Normalizer( `+`( args ) / nargs ):

This can be called as in the following examples.

 
> mean( 1, 2, 3, 4, 5 );
3
 
> mean( a + b, b + c, c + d, d + e, e + a );
2 a 2 b 2 c 2 d 2 e
--- + --- + --- + --- + ---
5 5 5 5 5
 
> mean(); # again, an exception is raised
Error, (in mean) numeric exception: division by zero
 

If desired, we can add argument type-checking as follows.

mean := ( s :: seq(algebraic) ) -> Normalizer( `+`( args ) / nargs ):

[edit] Mathematica

Modify the built-in Mean function to give 0 for empty vectors (lists in Mathematica):

Unprotect[Mean];
Mean[{}] := 0

Examples:

Mean[{3,4,5}]
Mean[{3.2,4.5,5.9}]
Mean[{-4, 1.233}]
Mean[{}]
Mean[{1/2,1/3,1/4,1/5}]
Mean[{a,c,Pi,-3,a}]

gives (a set of integers gives back an integer or a rational, a set of floats gives back a float, a set of rationals gives a rational back, a list of symbols and numbers keeps the symbols exact and a mix of exact and approximate numbers gives back an approximate number):

4
4.53333
-1.3835
0
77/240
1/5 (-3+2 a+c+Pi)

[edit] Mathprog

Summing the vector and then dividing the sum by the vector's length is slightly less boring than calling a builtin function Mean or similar.

Mathprog is never boring so this program finds a number M such that when M is subtracted from each value in the vector a second vector is formed with the property that the sum of the elements in the second vector is zero. In this case M is the Arithmetic Mean.

Euclid proved that for any vector there is only one such number and from this derived the Division Theorem.

To make it more interesting I find the Arithmectic Mean of more than a million Integers.

 
/*Arithmetic Mean of a large number of Integers
- or - solve a very large constraint matrix
over 1 million rows and columns
Nigel_Galloway
March 18th., 2008.
*/
 
param e := 20;
set Sample := {1..2**e-1};
 
var Mean;
var E{z in Sample};
 
/* sum of variances is zero */
zumVariance: sum{z in Sample} E[z] = 0;
 
/* Mean + variance[n] = Sample[n] */
variances{z in Sample}: Mean + E[z] = z;
 
solve;
 
printf "The arithmetic mean of the integers from 1 to %d is %f\n", 2**e-1, Mean;
 
end;
 

When run this produces:

 
GLPSOL: GLPK LP/MIP Solver, v4.47
Parameter(s) specified in the command line:
--nopresol --math AM.mprog
Reading model section from AM.mprog...
24 lines were read
Generating zumVariance...
Generating variances...
Model has been successfully generated
Scaling...
A: min|aij| = 1.000e+000 max|aij| = 1.000e+000 ratio = 1.000e+000
Problem data seem to be well scaled
Constructing initial basis...
Size of triangular part = 1048575
GLPK Simplex Optimizer, v4.47
1048576 rows, 1048576 columns, 3145725 non-zeros
0: obj = 0.000000000e+000 infeas = 5.498e+011 (1)
* 1: obj = 0.000000000e+000 infeas = 0.000e+000 (0)
OPTIMAL SOLUTION FOUND
Time used: 2.0 secs
Memory used: 1393.8 Mb (1461484590 bytes)
The arithmetic mean of the integers from 1 to 1048575 is 524288.000000
Model has been successfully processed
 

[edit] MATLAB

function meanValue = findmean(setOfValues)
meanValue = mean(setOfValues);
end

[edit] Maxima

load("descriptive");
mean([2, 7, 11, 17]);

[edit] MAXScript

fn mean data =
(
total = 0
for i in data do
(
total += i
)
if data.count == 0 then 0 else total as float/data.count
)
 
print (mean #(3, 1, 4, 1, 5, 9))

[edit] МК-61/52

0	П0	П1	С/П	ИП0	ИП1	*	+	ИП1	1
+ П1 / П0 БП 03

Instruction: В/О С/П Number С/П Number ...

Each time you press the С/П on the indicator would mean already entered numbers.

[edit] Modula-2

PROCEDURE  Avg;
 
VAR avg : REAL;
 
BEGIN
avg := sx / n;
InOut.WriteString ("Average = ");
InOut.WriteReal (avg, 8, 2);
InOut.WriteLn
END Avg;

OR

PROCEDURE Average (Data  : ARRAY OF REAL;   Samples : CARDINAL) : REAL;
 
(* Calculate the average over 'Samples' values, stored in array 'Data'. *)
 
VAR sum : REAL;
n : CARDINAL;
 
BEGIN
sum := 0.0;
FOR n := 0 TO Samples - 1 DO
sum := sum + Data [n]
END;
RETURN sum / FLOAT(Samples)
END Average;

[edit] MUMPS

MEAN(X)
 ;X is assumed to be a list of numbers separated by "^"
QUIT:'$DATA(X) "No data"
QUIT:X="" "Empty Set"
NEW S,I
SET S=0,I=1
FOR QUIT:I>$L(X,"^") SET S=S+$P(X,"^",I),I=I+1
QUIT (S/$L(X,"^"))
USER>W $$MEAN^ROSETTA
No data
USER>W $$MEAN^ROSETTA("")
Empty Set
USER>
 
USER>W $$MEAN^ROSETTA("1^6^12^4")
5.75

[edit] Nemerle

using System;
using System.Console;
using Nemerle.Collections;
 
module Mean
{
ArithmeticMean(x : list[int]) : double
{
|[] => 0.0
|_ =>(x.FoldLeft(0, _+_) :> double) / x.Length
}
 
Main() : void
{
WriteLine("Mean of [1 .. 10]: {0}", ArithmeticMean($[1 .. 10]));
}
}

[edit] NetRexx

/* NetRexx */
options replace format comments java crossref symbols nobinary
 
launchSample()
return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method arithmeticMean(vv = Vector) public static signals DivideException returns Rexx
sum = 0
n_ = Rexx
loop n_ over vv
sum = sum + n_
end n_
mean = sum / vv.size()
 
return mean
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method launchSample() public static
TRUE_ = 1 == 1
FALSE_ = \TRUE_
tracing = FALSE_
vectors = getSampleData()
loop v_ = 0 to vectors.length - 1
say 'Average of:' vectors[v_].toString()
do
say ' =' arithmeticMean(vectors[v_])
catch dex = DivideException
say 'Caught "Divide By Zero"; bypassing...'
if tracing then dex.printStackTrace()
catch xex = RuntimeException
say 'Caught unspecified run-time exception; bypassing...'
if tracing then xex.printStackTrace()
end
say
end v_
return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method getSampleData() private static returns Vector[]
seed = 1066
rng = Random(seed)
vectors =[ -
Vector(Arrays.asList([Rexx 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])), -
Vector(), -
Vector(Arrays.asList([Rexx rng.nextInt(seed), rng.nextInt(seed), rng.nextInt(seed), rng.nextInt(seed), rng.nextInt(seed), rng.nextInt(seed)])), -
Vector(Arrays.asList([Rexx rng.nextDouble(), rng.nextDouble(), rng.nextDouble(), rng.nextDouble(), rng.nextDouble(), rng.nextDouble(), rng.nextDouble()])), -
Vector(Arrays.asList([Rexx '1.0', '2.0', 3.0])), -
Vector(Arrays.asList([Rexx '1.0', 'not a number', 3.0])) -
]
return vectors
 

Output:

Average of: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
          = 5.5

Average of: []
Caught "Divide By Zero"; bypassing...

Average of: [294, 726, 945, 828, 1031, 825]
          = 774.833333

Average of: [0.3318379308729921, 0.7612271993941618, 0.9517290891755477, 0.7687823629521795, 0.2201768257213939, 0.1083471020993242, 0.5158554699332363]
          = 0.52256514

Average of: [1.0, 2.0, 3.0]
          = 2

Average of: [1.0, not a number, 3.0]
Caught unspecified run-time exception; bypassing...

[edit] NewLISP

(define (Mean Lst)
(if (empty? Lst)
0
(/ (apply + Lst) (length Lst))))
 
(Mean (sequence 1 1000))-> 500
(Mean '()) -> 0

[edit] Nial

in the standard way, mean is

mean is / [sum, tally] 
 
mean 6 2 4
= 4

but it fails with 0 length vectors. so using a tally with a minimum value 1

dtally is recur [ empty rest, 1 first, 1 first, plus, rest ]
mean is / [sum, dtally]
 
mean []
=0

[edit] Nimrod

Translation of: C
import strutils
 
proc mean(xs): float =
for x in xs:
result += x
result = result / float(xs.len)
 
var v = @[1.0, 2.0, 2.718, 3.0, 3.142]
for i in 0..5:
echo "mean of first ", v.len, " = ", formatFloat(mean(v), precision = 0)
v.setLen(v.high)

Output:

mean of first 5 = 2.372
mean of first 4 = 2.1795
mean of first 3 = 1.906
mean of first 2 = 1.5
mean of first 1 = 1
mean of first 0 = -nan

[edit] Niue

 
[ [ , len 1 - at ! ] len 3 - times swap , ] 'map ; ( a Lisp like map, to sum the stack )
[ len 'n ; [ + ] 0 n swap-at map n / ] 'avg ;
 
1 2 3 4 5 avg .
=> 3
3.4 2.3 .01 2.0 2.1 avg .
=> 1.9619999999999997
 

[edit] Oberon-2

Oxford Oberon-2

 
MODULE AvgMean;
IMPORT Out;
CONST MAXSIZE = 10;
PROCEDURE Avg(a: ARRAY OF REAL; items: INTEGER): REAL;
VAR
i: INTEGER;
total: REAL;
BEGIN
total := 0.0;
FOR i := 0 TO LEN(a) - 1 DO
total := total + a[i]
END;
RETURN total/LEN(a)
END Avg;
VAR
ary: ARRAY MAXSIZE OF REAL;
BEGIN
ary[0] := 10.0;
ary[1] := 11.01;
ary[2] := 12.02;
ary[3] := 13.03;
ary[4] := 14.04;
ary[5] := 15.05;
ary[6] := 16.06;
ary[7] := 17.07;
ary[8] := 18.08;
ary[9] := 19.09;
Out.Fixed(Avg(ary),4,2);Out.Ln
END AvgMean.
 

Output:

14.55

[edit] Objeck

 
function : native : PrintAverage(values : FloatVector) ~ Nil {
values->Average()->PrintLine();
}
 

[edit] OCaml

These functions return a float:

let mean_floats = function
| [] -> 0.
| xs -> List.fold_left (+.) 0. xs /. float_of_int (List.length xs)
 
let mean_ints xs = mean_floats (List.map float_of_int xs)

the previous code is easier to read and understand, though if you wish the fastest implementation to use in production code notice several points: it is possible to save a call to List.length computing the length through the List.fold_left, and for mean_ints it is possible to save calling float_of_int on every numbers, converting only the result of the addition. (also when using List.map and when the order is not important, you can use List.rev_map instead to save an internal call to List.rev). Also the task asks to return 0 on empty lists, but in OCaml this case would rather be handled by an exception.

let mean_floats xs =
if xs = [] then
invalid_arg "empty list"
else
let total, length =
List.fold_left
(fun (tot,len) x -> (x +. tot), len +. 1.)
(0., 0.) xs
in
(total /. length)
;;
 
 
let mean_ints xs =
if xs = [] then
invalid_arg "empty list"
else
let total, length =
List.fold_left
(fun (tot,len) x -> (x + tot), len +. 1.)
(0, 0.) xs
in
(float total /. length)
;;

[edit] Octave

GNU Octave has a mean function (from statistics package), but it does not handle an empty vector; an implementation that allows that is:

function m = omean(l)
if ( numel(l) == 0 )
m = 0;
else
m = mean(l);
endif
endfunction
 
disp(omean([]));
disp(omean([1,2,3]));

If the data contains missing value, encoded as non-a-number:

function m = omean(l)
n = sum(~isnan(l));
l(isnan(l))=0;
s = sum(l);
m = s./n;
end;

[edit] ooRexx

 
call testAverage .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
call testAverage .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11)
call testAverage .array~of(10, 20, 30, 40, 50, -100, 4.7, -11e2)
call testAverage .array~new
 
::routine testAverage
use arg numbers
say "numbers =" numbers~toString("l", ", ")
say "average =" average(numbers)
say
 
::routine average
use arg numbers
-- return zero for an empty list
if numbers~isempty then return 0
 
sum = 0
do number over numbers
sum += number
end
return sum/numbers~items
 

Output:

numbers = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
average = 5.5

numbers = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11
average = 3.674

numbers = 10, 20, 30, 40, 50, -100, 4.7, -1100
average = -130.6625

numbers =
average = 0

[edit] Oz

A version working on floats:

declare
fun {Mean Xs}
{FoldL Xs Number.'+' 0.0} / {Int.toFloat {Length Xs}}
end
in
{Show {Mean [3. 1. 4. 1. 5. 9.]}}

[edit] PARI/GP

avg(v)={
if(#v,vecsum(v)/#v)
};

[edit] Pascal

Program Mean;
 
function DoMean(vector: array of double): double;
var
sum: double;
i, len: integer;
begin
sum := 0;
len := length(vector);
if len > 0 then
begin
for i := low(vector) to high(vector) do
sum := sum + vector[i];
sum := sum / len;
end;
DoMean := sum;
end;
 
const
vector: array [3..8] of double = (3.0, 1.0, 4.0, 1.0, 5.0, 9.0);
var
i: integer;
begin
writeln('Calculating the arithmetic mean of a series of numbers:');
write('Numbers: [ ');
for i := low(vector) to high(vector) do
write (vector[i]:3:1, ' ');
writeln (']');
writeln('Mean: ', DoMean(vector):10:8);
end.

Output:

Calculating the arithmetic mean of a series of numbers:
Numbers: [ 3.0 1.0 4.0 1.0 5.0 9.0 ]
Mean: 3.83333333

Alternative version using the Math unit:

Program DoMean;
uses math;
const
vector: array [3..8] of double = (3.0, 1.0, 4.0, 1.0, 5.0, 9.0);
var
i: integer;
mean: double;
begin
writeln('Calculating the arithmetic mean of a series of numbers:');
write('Numbers: [ ');
for i := low(vector) to high(vector) do
write (vector[i]:3:1, ' ');
writeln (']');
mean := 0;
if length(vector) > 0 then
mean := sum(vector)/length(vector);
writeln('Mean: ', mean:10:8);
end.

[edit] Perl

sub avg {
@_ or return 0;
my $sum = 0;
$sum += $_ foreach @_;
return $sum/@_;
}
 
print avg(qw(3 1 4 1 5 9)), "\n";

With module Data::Average. (For zero-length arrays, returns the empty list.)

use Data::Average;
 
my $d = Data::Average->new;
$d->add($_) foreach qw(3 1 4 1 5 9);
print $d->avg, "\n";

[edit] Perl 6

Works with: Rakudo version #21 "Seattle"
sub mean (@a) { ([+] @a) / (@a || 1) }

[edit] PHP

$nums = array(3, 1, 4, 1, 5, 9);
if ($nums)
echo array_sum($nums) / count($nums), "\n";
else
echo "0\n";

[edit] PL/I

arithmetic_mean = sum(A)/dimension(A,1);

[edit] PicoLisp

(de mean (Lst)
(if (atom Lst)
0
(/ (apply + Lst) (length Lst)) ) )

Output:

: (mean (range 1 1000))
-> 500

[edit] Pop11

define mean(v);
lvars n = length(v), i, s = 0;
if n = 0 then
return(0);
else
for i from 1 to n do
s + v(i) -> s;
endfor;
endif;
return(s/n);
enddefine;

[edit] PostScript

 
/findmean{
/x exch def
/sum 0 def
/i 0 def
x length 0 eq
{}
{
x length{
/sum sum x i get add def
/i i 1 add def
}repeat
/sum sum x length div def
}ifelse
sum ==
}def
 
Library: initlib
Works with: Ghostscript
 
/avg {
dup length
{0 gt} {
exch 0 {add} fold exch div
} {
exch pop
} ifte
}.
 

[edit] PowerShell

The hard way by calculating a sum and dividing:

function mean ($x) {
if ($x.Count -eq 0) {
return 0
} else {
$sum = 0
foreach ($i in $x) {
$sum += $i
}
return $sum / $x.Count
}
}

or, shorter, by using the Measure-Object cmdlet which already knows how to compute an average:

function mean ($x) {
if ($x.Count -eq 0) {
return 0
} else {
return ($x | Measure-Object -Average).Average
}
}

[edit] Prolog

Works with: SWI-Prolog version 6.6
 
mean(List, Mean) :-
length(List, Length),
sumlist(List, Sum),
Mean is Sum / Length.
 

[edit] PureBasic

Procedure.d mean(List number())
Protected sum=0
 
ForEach number()
sum + number()
Next
ProcedureReturn sum / ListSize(number())
; Depends on programm if zero check needed, returns nan on division by zero
EndProcedure

[edit] Python

Works with: Python version 3.0
.
Works with: Python version 2.6

Uses fsum which tracks multiple partial sums to avoid losing precision

from math import fsum
def average(x):
return fsum(x)/float(len(x)) if x else 0
print (average([0,0,3,1,4,1,5,9,0,0]))
print (average([1e20,-1e-20,3,1,4,1,5,9,-1e20,1e-20]))
Output:
2.3
2.3


Works with: Python version 2.5
def average(x):
return sum(x)/float(len(x)) if x else 0
print (average([0,0,3,1,4,1,5,9,0,0]))
print (average([1e20,-1e-20,3,1,4,1,5,9,-1e20,1e-20]))
Output:

(Notice how the second call gave the wrong result)

2.3
1e-21


Works with: Python version 2.4
def avg(data):
if len(data)==0:
return 0
else:
return sum(data)/float(len(data))
print avg([0,0,3,1,4,1,5,9,0,0])
Output:
2.3

[edit] R

R has its mean function but it does not allow for NULL (void vectors or whatever) as argument: in this case it raises a warning and the result is NA. An implementation that does not suppress the warning could be:

omean <- function(v) {
m <- mean(v)
ifelse(is.na(m), 0, m)
}

[edit] Racket

Racket's math library (available in v5.3.2 and newer) comes with a mean function that works on arbitrary sequences.

 
#lang racket
(require math)
 
(mean (in-range 0 1000)) ; -> 499 1/2
(mean '(2 2 4 4))  ; -> 3
(mean #(3 4 5 8))  ; -> 5
 

[edit] REBOL

rebol [
Title: "Arithmetic Mean (Average)"
Author: oofoe
Date: 2009-12-11
URL: http://rosettacode.org/wiki/Average/Arithmetic_mean
]

 
average: func [v /local sum][
if empty? v [return 0]
 
sum: 0
forall v [sum: sum + v/1]
sum / length? v
]
 
; Note precision loss as spread increased.
 
print [mold x: [] "->" average x]
print [mold x: [3 1 4 1 5 9] "->" average x]
print [mold x: [1000 3 1 4 1 5 9 -1000] "->" average x]
print [mold x: [1e20 3 1 4 1 5 9 -1e20] "->" average x]

Output:

[] -> 0
[3 1 4 1 5 9] -> 3.83333333333333
[1000 3 1 4 1 5 9 -1000] -> 2.875
[1E+20 3 1 4 1 5 9 -1E+20] -> 0.0

[edit] REXX

The vectors (list) can contain any valid numbers.

/*REXX pgm finds the averages/arithmetic mean of several lists (vectors)*/
@.1 = 10 9 8 7 6 5 4 3 2 1
@.2 = 10 9 8 7 6 5 4 3 2 1 0 0 0 0 .11
@.3 = '10 20 30 40 50 -100 4.7 -11e2'
@.4 = '1 2 3 4 five 6 7 8 9 10.1. ±2'
@.5 = 'World War I & World War II'
@.6 = ''
do j=1 for 6
say 'numbers = ' @.j; say 'average = ' avg(@.j); say
end /*t*/
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────AVG subroutine──────────────────────*/
avg: procedure; parse arg x; w=words(x); s=0; $=left('',20)
if w==0 then return 'N/A: ───[null vector.]'
do k=1 for w; _=word(x,k)
if datatype(_,'N') then do; s=s+_; iterate; end
say $ '***error!*** non-numeric: ' _; w=w-1 /*adjust W*/
end /*k*/
if w==0 then return 'N/A: ───[no numeric values.]'
return s/max(1,w)

output

numbers =  10 9 8 7 6 5 4 3 2 1
average =  5.5

numbers =  10 9 8 7 6 5 4 3 2 1 0 0 0 0 .11
average =  3.674

numbers =  10 20 30 40 50 -100 4.7 -11e2
average =  -130.6625

numbers =  1 2 3 4 five 6 7 8 9 10.1. ±2
                     ***error!*** non-numeric:  five
                     ***error!*** non-numeric:  10.1.
                     ***error!*** non-numeric:  ±2
average =  5

numbers =  World War I & World War II
                     ***error!*** non-numeric:  World
                     ***error!*** non-numeric:  War
                     ***error!*** non-numeric:  I
                     ***error!*** non-numeric:  &
                     ***error!*** non-numeric:  World
                     ***error!*** non-numeric:  War
                     ***error!*** non-numeric:  II
average =  N/A: ───[no numeric values.]

numbers =
average =  N/A: ───[null vector.]

[edit] Ruby

def mean(nums)
nums.inject(0.0, :+) / nums.size
end
 
nums = [3, 1, 4, 1, 5, 9]
nums.size.downto(0) do |i|
ary = nums[0,i]
puts "array size #{ary.size} : #{mean(ary)}"
end
Output:
array size 6 : 3.8333333333333335
array size 5 : 2.8
array size 4 : 2.25
array size 3 : 2.6666666666666665
array size 2 : 2.0
array size 1 : 3.0
array size 0 : NaN

[edit] Run BASIC

print "Gimme the number in the array:";input numArray
dim value(numArray)
for i = 1 to numArray
value(i) = i * 1.5
next
 
for i = 1 to total
totValue = totValue +value(numArray)
next
if totValue <> 0 then mean = totValue/numArray
print "The mean is: ";mean

[edit] Rust

This program works for Rust 0.11-pre.

fn sum(arr: &[f64]) -> f64 {
return arr.iter().fold(0.0, |p,q| p + *q);
}
 
fn mean(arr: &[f64]) -> f64 {
return sum(arr) / arr.len() as f64;
}
 
fn main() {
let v = &[2.0, 3.0, 5.0, 7.0, 13.0, 21.0, 33.0, 54.0];
println!("mean of {}: {}", v, mean(v));
 
let w = &[];
println!("mean of {}: {}", w, mean(w));
}

Output:

mean of [2, 3, 5, 7, 13, 21, 33, 54]: 17.25
mean of []: -NaN

[edit] Sather

Built to work with VEC, ("geometric" vectors), whose elements must be floats. A 0-dimension vector yields "nan".

class VECOPS is
mean(v:VEC):FLT is
m ::= 0.0;
loop m := m + v.aelt!; end;
return m / v.dim.flt;
end;
end;
 
class MAIN is
main is
v ::= #VEC(|1.0, 5.0, 7.0|);
#OUT + VECOPS::mean(v) + "\n";
end;
end;

[edit] Scala

Using Scala 2.7, this has to be defined for each numeric type:

def mean(s: Seq[Int]) = s.foldLeft(0)(_+_) / s.size

However, Scala 2.8 gives much more flexibility, but you still have to opt between integral types and fractional types. For example:

def mean[T](s: Seq[T])(implicit n: Integral[T]) = {
import n._
s.foldLeft(zero)(_+_) / fromInt(s.size)
}

This can be used with any subclass of Sequence on integral types, up to and including BigInt. One can also create singletons extending Integral for user-defined numeric classes. Likewise, Integral can be replaced by Fractional in the code to support fractional types, such as Float and Double.

Alas, Scala 2.8 also simplifies the task in another way:

def mean[T](s: Seq[T])(implicit n: Fractional[T]) = n.div(s.sum, n.fromInt(s.size))

Here we show a function that supports fractional types. Instead of importing the definitions from n, we are calling them on n itself. And because we did not import them, the implicit definitions that would allow us to use / were not imported as well. Finally, we use sum instead of foldLeft.

[edit] Scheme

(define (mean l)
(if (null? l)
0
(/ (apply + l) (length l))))
> (mean (list 3 1 4 1 5 9))
3 5/6

[edit] Seed7

$ include "seed7_05.s7i";
include "float.s7i";
 
const array float: numVector is [] (1.0, 2.0, 3.0, 4.0, 5.0);
 
const func float: mean (in array float: numbers) is func
result
var float: result is 0.0;
local
var float: total is 0.0;
var float: num is 0.0;
begin
if length(numbers) <> 0 then
for num range numbers do
total +:= num;
end for;
result := total / flt(length(numbers));
end if;
end func;
 
const proc: main is func
begin
writeln(mean(numVector));
end func;

[edit] Sidef

func avg(list) {
list.is_a(Array) || return nil;
list.len > 0 || return 0;
list.sum / list.len;
}
 
say avg([Math.inf, Math.inf]);
say avg([3,1,4,1,5,9]);
say avg([1e+20, 3, 1, 4, 1, 5, 9, -1e+20]);
say avg([10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0.11]);
say avg([10, 20, 30, 40, 50, -100, 4.7, -1100]);
Output:
inf
3.833333333333333333333333333333333333333
2.875
3.674
-130.6625

[edit] Slate

[|:list| (list reduce: #+ `er ifEmpty: [0]) / (list isEmpty ifTrue: [1] ifFalse: [list size])] applyWith: #(3 1 4 1 5 9).
[|:list| (list reduce: #+ `er ifEmpty: [0]) / (list isEmpty ifTrue: [1] ifFalse: [list size])] applyWith: {}.

[edit] Smalltalk

 
| numbers |
 
numbers := #(1 2 3 4 5 6 7 8).
(numbers isEmpty
ifTrue:[0]
ifFalse: [
(numbers inject: 0 into: [:sumSoFar :eachElement | sumSoFar + eachElement]) / numbers size ]
) displayNl.
 

However, the empty check can be omitted, as inject returns the injected value for empty collections, and we probably do not care for the average of nothing (i.e. the division by zero exception):

 
| numbers |
 
numbers := #(1 2 3 4 5 6 7 8).
( numbers inject: 0 into: [:sumSoFar :eachElement | sumSoFar + eachElement]) / numbers size] ) displayNl.
 

also, most Smalltalk's collection classes already provide sum and average methods, which makes it:

Works with: Pharo
Works with: Smalltalk/X
 
| numbers |
 
numbers := #(1 2 3 4 5 6 7 8).
(numbers sum / numbers size) displayNl.
 

or

 
| numbers |
 
numbers := #(1 2 3 4 5 6 7 8).
numbers average displayNl.
 

[edit] SNOBOL4

Works with: Macro Spitbol
Works with: Snobol4+
Works with: CSnobol
        define('avg(a)i,sum') :(avg_end)
avg i = i + 1; sum = sum + a<i> :s(avg)
avg = 1.0 * sum / prototype(a) :(return)
avg_end
 
* # Fill arrays
str = '1 2 3 4 5 6 7 8 9 10'; arr = array(10)
loop i = i + 1; str len(p) span('0123456789') . arr<i> @p :s(loop)
empty = array(1) ;* Null vector
 
* # Test and display
output = '[' str '] -> ' avg(arr)
output = '[ ] -> ' avg(empty)
end

Output:

[1 2 3 4 5 6 7 8 9 10] -> 5.5
[ ] -> 0.

[edit] Standard ML

These functions return a real:

fun mean_reals [] = 0.0
| mean_reals xs = foldl op+ 0.0 xs / real (length xs);
 
val mean_ints = mean_reals o (map real);

The previous code is easier to read and understand, though if you want the fastest implementation to use in production code notice several points: it is possible to save a call to length computing the length through the foldl, and for mean_ints it is possible to save calling real on every numbers, converting only the result of the addition. Also the task asks to return 0 on empty lists, but in Standard ML this case would rather be handled by an exception.

fun mean_reals [] = raise Empty
| mean_reals xs = let
val (total, length) =
foldl
(fn (x, (tot,len)) => (x + tot, len + 1.0))
(0.0, 0.0) xs
in
(total / length)
end;
 
 
fun mean_ints [] = raise Empty
| mean_ints xs = let
val (total, length) =
foldl
(fn (x, (tot,len)) => (x + tot, len + 1.0))
(0, 0.0) xs
in
(real total / length)
end;

[edit] Swift

func meanDoubles(s: [Double]) -> Double {
return s.reduce(0, +) / Double(s.count)
}
func meanInts(s: [Int]) -> Double {
return meanDoubles(s.map{Double($0)})
}

[edit] Tcl

package require Tcl 8.5
proc mean args {
if {[set num [llength $args]] == 0} {return 0}
expr {[tcl::mathop::+ {*}$args] / double($num)}
}
mean 3 1 4 1 5 9 ;# ==> 3.8333333333333335

[edit] TI-89 BASIC

Define rcmean(nums) = when(dim(nums) = 0, 0, mean(nums))

[edit] Trith

: mean dup empty? [drop 0] [dup [+] foldl1 swap length /] branch ;
 
[3 1 4 1 5 9] mean

[edit] UnixPipes

This example is incorrect. There is a race between parallel commands. cat count might try to read the file before wc -l >count writes it. This may cause an error like cat: count: No such file or directory, then bc: stdin:1: syntax error: ) unexpected. Please fix the code and remove this message.


Uses ksh93-style process substitution. Also overwrites the file named count in the current directory.

Works with: bash
term() {
b=$1;res=$2
echo "scale=5;$res+$b" | bc
}
 
sum() {
(read B; res=$1;
test -n "$B" && (term $B $res) || (term 0 $res))
}
 
fold() {
func=$1
(while read a ; do
fold $func | $func $a
done)
}
 
mean() {
tee >(wc -l > count) | fold sum | xargs echo "scale=5;(1/" $(cat count) ") * " | bc
}
 
(echo 3; echo 1; echo 4) | mean

[edit] UNIX Shell

This example uses expr, so it only works with integers. It checks that each string in the list is an integer.

mean() {
if expr $# >/dev/null; then
(count=0
sum=0
while expr $# \> 0 >/dev/null; do
sum=`expr $sum + "$1"`
result=$?
expr $result \> 1 >/dev/null && exit $result
 
count=`expr $count + 1`
shift
done
expr $sum / $count)
else
echo 0
fi
}
 
printf "test 1: "; mean # 0
printf "test 2: "; mean 300 # 300
printf "test 3: "; mean 300 100 400 # 266
printf "test 4: "; mean -400 400 -1300 200 # -275
printf "test 5: "; mean - # expr: syntax error
printf "test 6: "; mean 1 2 A 3 # expr: non-numeric argument

[edit] Ursala

There is a library function for means already, although it doesn't cope with empty vectors. A mean function could be defined as shown for this task.

#import nat
#import flo
 
mean = ~&?\0.! div^/plus:-0. float+ length
 
#cast %e
 
example = mean <5.,3.,-2.,6.,-4.>

output:

1.600000e+00


[edit] V

[mean
[sum 0 [+] fold].
dup sum
swap size [[1 <] [1]] when /
].

[edit] Vala

Using array to hold the numbers of the list:

 
double arithmetic(double[] list){
double mean;
double sum = 0;
 
if (list.length == 0)
return 0.0;
foreach(double number in list){
sum += number;
} // foreach
 
mean = sum / list.length;
 
return mean;
} // end arithmetic mean
 
public static void main(){
double[] test = {1.0, 2.0, 5.0, -5.0, 9.5, 3.14159};
double[] zero_len = {};
 
double mean = arithmetic(test);
double mean_zero = arithmetic(zero_len);
 
stdout.printf("%s\n", mean.to_string());
stdout.printf("%s\n", mean_zero.to_string());
}
 

Output:

2.6069316666666666
0

[edit] Vedit macro language

The numeric data is stored in current edit buffer as ASCII strings, one value per line.

#1 = 0			// Sum
#2 = 0 // Count
BOF
While(!At_EOF) {
#1 += Num_Eval(SIMPLE)
#2++
Line(1, ERRBREAK)
}
if (#2) { #1 /= #2 }
Num_Type(#1)

[edit] Vim Script

Throws an exception if the list is empty.

function Mean(lst)
if empty(a:lst)
throw "Empty"
endif
let sum = 0.0
for i in a:lst
let sum += i
endfor
return sum / len(a:lst)
endfunction

[edit] Wortel

@let {
 ; using a fork (sum divided-by length)
mean1 @(@sum / #)
 
 ; using a function with a named argument
mean2 &a / @sum a #a
 
[[
 !mean1 [3 1 4 1 5 9 2]
 !mean2 [3 1 4 1 5 9 2]
]]
}

Returns:

[3.5714285714285716 3.5714285714285716]

[edit] XPL0

code CrLf=9;
code real RlOut=48;
 
func real Mean(A, N);
real A; int N;
real S; int I;
[if N=0 then return 0.0;
S:= 0.0;
for I:= 0 to N-1 do
S:= S+A(I);
return S/float(N);
]; \Mean
 
real Test;
[Test:= [1.0, 2.0, 5.0, -5.0, 9.5, 3.14159];
RlOut(0, Mean(Test, 6)); CrLf(0);
]

Output:

    2.60693

[edit] XSLT

Where $values is some variable indicating a set of nodes containing numbers, the average is given by the XPath expression:

sum($values) div count($values)

[edit] Runnable example

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="text"/>
 
<xsl:template match="/">
<xsl:variable name="values" select="/*/*"/>
<xsl:value-of select="sum($values) div count($values)"/>
</xsl:template>
</xsl:stylesheet>

Sample input:

<numbers>
<!-- Average is 2.4 -->
<number>1</number>
<number>1</number>
<number>2</number>
<number>3</number>
<number>5</number>
</numbers>

[edit] Yorick

func mean(x) {
if(is_void(x)) return 0;
return x(*)(avg);
}

[edit] zkl

fcn mean(a,b,c,etc){z:=vm.arglist; z.reduce('+,0.0)/z.len()}

Converts int to floats (implicitly).

zkl: mean(3,1,4,1,5,9)
3.83333

zkl: mean()
Exception thrown: MathError(NaN (Not a number))

To pass in a vector/list:

fcn mean(z){z.reduce('+,0.0)/z.len()}
zkl: mean(T(3,1,4,1,5,9))
3.83333
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox