Averages/Arithmetic mean
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
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. The program should work on a zero-length vector (with an answer of 0).
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.
<lang 6502asm>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</lang>
ActionScript
<lang 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; }</lang>
Ada
This example shows how to pass a zero length vector as well as a larger vector. <lang ada>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;</lang> Output:
3.83333 0.00000
ALGOL 68
<lang algol68>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))
)</lang>
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") <lang amigae>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</lang>
AutoHotkey
<lang autohotkey>i = 10 Loop, % i {
Random, v, -3.141592, 3.141592 list .= v "`n" sum += v
} MsgBox, % i ? list "`nmean: " sum/i:0</lang>
AWK
<lang 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)
}</lang>
APL
<lang apl> X←3 1 4 1 5 9
(+/X)÷⍴X
3.833333333</lang>
BASIC
Assume the numbers are in a DIM named nums. <lang qbasic>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</lang>
BBC BASIC
To calculate the mean of an array: <lang BBC BASIC>
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)
</lang> Michael Hutton 14:02, 29 May 2011 (UTC)
Befunge
This example can't deal with null inputs (i.e., blank input, or first input is 0 (zero)). <lang befunge>0001>p&: #v_$::01g/.@
^10+1g10+<
Enter 0 (zero) to finish.</lang>
Brainf***
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? <lang bf>>,[-<+>>+<],<[->-<]>[-->+<]>.</lang>
Brat
<lang brat>mean = { list |
true? list.empty?, 0, { list.reduce(0, :+) / list.length }
}
p mean 1.to 10 #Prints 5.5</lang>
C
This implementation uses a plain old static array of doubles for the numeric vector.
<lang c>#include <stdio.h>
double mean(double *p, unsigned qty) /* Calculates the mean of qty doubles beginning at p. */
{if (qty == 0) return 0; double total = 0; for (int i = 0 ; i < qty ; ++i) total += p[i]; return total / qty;}
int main(void)
{double test[6] = {1.0, 2.0, 5.0, -5.0, 9.5, 3.14159}; printf("%lg\n", mean(test, 6)); return 0;}</lang>
C#
<lang csharp>using System; using System.Linq;
class Program {
static void Main() { Console.WriteLine(new[] { 1, 2, 3 }.Average()); }
}</lang>
C++
<lang cpp>#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();
}</lang>
Shorter (and more idiomatic) version:
<lang cpp>#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();
}</lang>
Idiomatic version templated on any kind of iterator:
<lang cpp>#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);
}</lang>
Chef
<lang 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.</lang>
Clojure
<lang lisp>(defn mean [sq]
(let [length (count sq)] (if (zero? length) 0 (/ (reduce + sq) length)))
)</lang>
Common Lisp
With Reduce
<lang lisp>(defun mean (sequence)
(let ((length (length sequence))) (if (zerop length) 0 (/ (reduce #'+ sequence) length))))</lang>
With Loop <lang lisp>(defun mean (sequence)
(loop for i in sequence with length = (length sequence) summing i into result finally return (/ result length)))</lang>
The loop version is buggy if sequence is the empty list.
D
<lang d>import std.stdio: writeln;
real mean(Range)(Range r) {
real sum = 0.0; int count = 0;
foreach (item; r) { sum += item; count++; }
if (count == 0) return 0.0; else return sum / count;
}
void main() {
int[] data; writeln("mean: ", data.mean()); data = [3, 1, 4, 1, 5, 9]; writeln("mean: ", data.mean());
}</lang>
Output:
mean: 0 mean: 3.83333
More functional style, same output: <lang d>import std.stdio, std.algorithm, std.range;
auto mean(Range)(Range r) {
auto len = walkLength(r); return len == 0 ? 0.0 : reduce!q{a + b}(0.0L, r) / len;
}
void main() {
int[] data; writeln("mean: ", data.mean()); data = [3, 1, 4, 1, 5, 9]; writeln("mean: ", data.mean());
}</lang> A (naive?) version to minimize precision loss : <lang d>import std.stdio, std.conv, std.algorithm, std.math, std.traits ;
CommonType!(T,real) mean(T)(T[] n ...) if(isNumeric!(T)) {
alias CommonType!(T,real) E ; auto num = n.dup ; sort!"abs(a) > abs(b)"(num) ; return reduce!"a+b"(0.0L, map!(to!E)(num)) / max(1,num.length) ;
}
void main() {
int[] empty ; // literal [] need casting, becoz T is unknown writefln("%8.5f", mean(empty)) ; // writefln("%8.5f", mean( 0,3,1,4,1,5,9,0)) ; writefln("%8.5f", mean([-1e20,3,1,4,1,5,9,1e20])) ;
}</lang> Output:
0.00000 2.87500 2.87500
E
Slightly generalized to support any object that allows iteration.
<lang e>def meanOrZero(numbers) {
var count := 0 var sum := 0 for x in numbers { sum += x count += 1 } return sum / 1.max(count)
}</lang>
Elena
<lang elena>#define basic'* = std'basic'*.
- define ctrl'* = std'patterns'*.
- class MeanAction
{
#field theValue. #field theCount. #role Empty { #method int'get = 0. #method evaluate : aValue [ theValue := basic'Real::0. theCount := basic'Integer::0. #shift. self evaluate:aValue. ] } #method new [ #shift Empty. ] #method int'get = theValue / theCount. #method evaluate : aValue [ theCount += 1. theValue += aValue. ]
}
- symbol Program =>
[
#var anAction := MeanAction. ctrl'Control run &list:(1, 2, 3, 4, 5, 6, 7, 8) &foreach:anAction. 'program'Output << anAction int.
]. </lang>
Erlang
<lang erlang>mean([]) -> 0; mean(L) -> lists:sum(L)/length(L).</lang>
Euphoria
<lang 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)</lang>
Factor
<lang factor>USING: math math.statistics ;
- arithmetic-mean ( seq -- n )
[ 0 ] [ mean ] if-empty ;</lang>
Tests:
<lang factor>( scratchpad ) { 2 3 5 } arithmetic-mean >float 3.333333333333333</lang>
Fantom
<lang 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)) } }
} </lang>
Forth
<lang 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</lang>
Fortran
In ISO Fortran 90 or later, use the SUM intrinsic, the SIZE intrinsic and the MAX intrinsic (to avoid divide by zero): <lang fortran>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)</lang>
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. <lang fsharp>let avg (a:float) (v:float) n =
a + (1. / ((float n) + 1.)) * (v - a)
let mean_series list =
let rec f a n list = match list with | [] -> a | h :: t -> f (avg a (float h) n) (n + 1) t f 0. 0 list</lang>
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]
GAP
<lang 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</lang>
Go
<lang go>package main
import (
"fmt" "math"
)
func mean(v []float64) float64 {
if len(v) == 0 { return 0 } var parts []float64 for _, x := range v { var i int for _, p := range parts { sum := p + x var err float64 if math.Fabs(x) < math.Fabs(p) { err = x - (sum - p) } else { 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))
}
func main() {
for _, v := range [][]float64{ []float64{}, // answer is 0 per task description []float64{3, 1, 4, 1, 5, 9}, []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) fmt.Printf("Mean of %d numbers is %g\n\n", len(v), mean(v)) }
}</lang> Output:
Vector: [] Mean of 0 numbers is 0 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
Groovy
<lang groovy>def avg = { list -> list == [] ? 0 : list.sum() / list.size() }</lang>
Test Program: <lang groovy>println avg(0..9) println avg([2,2,2,4,2]) println avg ([])</lang>
Output:
4.5 2.4 0
Haskell
This function works if the element type is an instance of Fractional: <lang haskell>mean :: (Fractional a) => [a] -> a mean [] = 0 mean xs = sum xs / Data.List.genericLength xs</lang>
But some types, e.g. integers, are not Fractional; the following function works for all Real types: <lang haskell>meanReals :: (Real a, Fractional b) => [a] -> b meanReals = mean . map realToFrac</lang>
If you want to avoid keeping the list in memory and traversing it twice:
<lang haskell>{-# 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)</lang>
HicEst
<lang hicest>REAL :: vec(100) ! no zero-length arrays in HicEst
vec = $ - 1/2 ! 0.5 ... 99.5 mean = SUM(vec) / LEN(vec) ! 50
END </lang>
Icon and Unicon
<lang icon>procedure main(args)
every (s := 0) +:= !args write((real(s)/(0 ~= *args)) | 0)
end</lang>
Sample outputs:
->am 1 2 3 4 5 6 7 4.0 ->am 0 ->
IDL
If truly only the mean is wanted, one could use
<lang idl>x = [3,1,4,1,5,9] print,mean(x)</lang>
But mean() is just a thin wrapper returning the zeroth element of moment() :
<lang idl>print,moment(x)
- ==>
3.83333 8.96667 0.580037 -1.25081</lang>
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>.
J
<lang j>mean=: +/ % #</lang>
That is, sum divided by the number of items. The verb also works on higher-ranked arrays. For example:
<lang j> 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</lang>
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.
<lang j>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</lang>
Java
Assume the numbers are in a double array called "nums". <lang java5>... double sum = 0; for(double i : nums){
sum += i;
} System.out.println("The mean is: " + ((nums.length != 0) ? (sum / nums.length) : 0)); ...</lang>
JavaScript
<lang 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</lang>
<lang javascript>function mean(a) {
return a.length ? Functional.reduce('+', 0, a) / a.length : 0;
}</lang>
Logo
<lang logo>to average :l
if empty? :l [output 0] output quotient apply "sum :l count :l
end print average [1 2 3 4] ; 2.5</lang>
Lua
<lang 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}))</lang>
Lucid
<lang lucid>avg(x)
where sum = first(x) fby sum + next(x); n = 1 fby n + 1; avg = sum / n; end</lang>
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.
<lang m4>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</lang> <lang m4>mean(0,100,200,300,400,500,600,700,800,900,1000)</lang>
Mathematica
Modify the built-in Mean function to give 0 for empty vectors (lists in Mathematica): <lang mathematica>Unprotect[Mean]; Mean[{}] := 0</lang> Examples: <lang mathematica>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}]</lang> 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): <lang mathematica>4 4.53333 -1.3835 0 77/240 1/5 (-3+2 a+c+Pi)</lang>
MATLAB
<lang Matlab>function meanValue = findmean(setOfValues)
meanValue = mean(setOfValues);
end</lang>
MAXScript
<lang 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))</lang>
Nial
in the standard way, mean is <lang nial>mean is / [sum, tally]
mean 6 2 4 = 4</lang> but it fails with 0 length vectors. so using a tally with a minimum value 1
<lang nial>dtally is recur [ empty rest, 1 first, 1 first, plus, rest ] mean is / [sum, dtally]
mean [] =0</lang>
Niue
<lang 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 </lang>
Objeck
<lang objeck> function : native : PrintAverage(values : FloatVector) ~ Nil {
values->Average()->PrintLine();
} </lang>
OCaml
These functions return a float:
<lang ocaml>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)</lang>
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.
<lang ocaml>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)
- </lang>
Octave
GNU Octave has a mean function (from statistics package), but it does not handle an empty vector; an implementation that allows that is:
<lang octave>function m = omean(l)
if ( numel(l) == 0 ) m = 0; else m = mean(l); endif
endfunction
disp(omean([])); disp(omean([1,2,3]));</lang>
Oz
A version working on floats: <lang oz>declare
fun {Mean Xs} {FoldL Xs Number.'+' 0.0} / {Int.toFloat {Length Xs}} end
in
{Show {Mean [3. 1. 4. 1. 5. 9.]}}</lang>
PARI/GP
<lang parigp>avg(v)={
if(#v,vecsum(v)/#v)
};</lang>
Perl
<lang perl>sub avg {
@_ or return 0; my $sum = 0; $sum += $_ foreach @_; return $sum/@_;
}
print avg(qw(3 1 4 1 5 9)), "\n";</lang>
With module Data::Average. (For zero-length arrays, returns the empty list.) <lang perl>use Data::Average;
my $d = Data::Average->new; $d->add($_) foreach qw(3 1 4 1 5 9); print $d->avg, "\n";</lang>
Perl 6
<lang perl6>sub mean (@a) { ([+] @a) / (@a || 1) }</lang>
PHP
<lang php>$nums = array(3, 1, 4, 1, 5, 9); if ($nums)
echo array_sum($nums) / count($nums), "\n";
else
echo "0\n";</lang>
PL/I
<lang PL/I> arithmetic_mean = sum(A)/dimension(A,1); </lang>
PicoLisp
<lang PicoLisp>(de mean (Lst)
(if (atom Lst) 0 (/ (apply + Lst) (length Lst)) ) )</lang>
Output:
: (mean (range 1 1000)) -> 500
Pop11
<lang 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;</lang>
PostScript
<lang> /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 </lang>
<lang postscript> /avg {
dup length {0 gt} { exch 0 {add} fold exch div } { exch pop } ifte
}. </lang>
PowerShell
The hard way by calculating a sum and dividing: <lang powershell>function mean ($x) {
if ($x.Count -eq 0) { return 0 } else { $sum = 0 foreach ($i in $x) { $sum += $i } return $sum / $x.Count }
}</lang>
or, shorter, by using the Measure-Object
cmdlet which already knows how to compute an average:
<lang powershell>function mean ($x) {
if ($x.Count -eq 0) { return 0 } else { return ($x | Measure-Object -Average).Average }
}</lang>
PureBasic
<lang 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</lang>
Python
.
Uses fsum which tracks multiple partial sums to avoid losing precision <lang python>from math import fsum def average(x):
return fsum(x)/float(len(x)) if x else 0
print (average([3,1,4,1,5,9])) print (average([1e20,3,1,4,1,5,9,-1e20]))</lang>
Output: <lang python>3.83333333333333 2.875</lang>
<lang python>def average(x):
return sum(x)/float(len(x)) if x else 0
print average([3,1,4,1,5,9]) print average([1e20,3,1,4,1,5,9,-1e20])</lang>
Output
(Notice how the second call gave the wrong result) <lang python>3.83333333333333 0.0</lang>
<lang python>def avg(data):
if len(data)==0: return 0 else: return sum(data)/float(len(data))
print avg([3,1,4,1,5,9])</lang>
Output: <lang python>3.83333333333333</lang>
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:
<lang R>omean <- function(v) {
m <- mean(v) ifelse(is.na(m), 0, m)
}</lang>
REBOL
<lang 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]</lang>
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
REXX
<lang rexx> test1='10 9 8 7 6 5 4 3 2 1' say 'numbers='test1 say 'average='avg(test1) say
test2='10 9 8 7 6 5 4 3 2 1 0 0 0 0 .11' say 'numbers='test2 say 'average='avg(test2) say
test3='10 20 30 40 50 -100 4.7 -11e2' say 'numbers='test3 say 'average='avg(test3) say
test4= say 'numbers='test4 say 'average='avg(test4) say
test5='1 2 3 4 five 6 7 8 9' say 'numbers='test5 say 'average='avg(test5) say
exit
/*---------------------AVG subroutine------------------*/ avg: procedure; arg y s=0
do j=1 to words(y) x=word(y,j) if \datatype(x,'N') then return '*error* non-numeric' x s=s+x end
return s/max(1,words(y)) </lang> 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= average=0 numbers=1 2 3 4 five 6 7 8 9 average=*error* non-numeric FIVE
Ruby
<lang ruby>nums = [3, 1, 4, 1, 5, 9] nums.empty? ? 0 : nums.inject(:+) / Float(nums.size)</lang>
Sather
Built to work with VEC, ("geometric" vectors), whose elements must be floats. A 0-dimension vector yields "nan". <lang sather>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;</lang>
Scala
Using Scala 2.7, this has to be defined for each numeric type:
<lang scala>def mean(s: Seq[Int]) = s.foldLeft(0)(_+_) / s.size</lang>
However, Scala 2.8 gives much more flexibility, but you still have to opt between integral types and fractional types. For example:
<lang scala>def mean[T](s: Seq[T])(implicit n: Integral[T]) = {
import n._ s.foldLeft(zero)(_+_) / fromInt(s.size)
}</lang>
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:
<lang scala>def mean[T](s: Seq[T])(implicit n: Fractional[T]) = n.div(s.sum, n.fromInt(s.size))</lang>
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.
Scheme
<lang scheme>(define (mean l)
(if (null? l) 0 (/ (apply + l) (length l))))</lang>
> (mean (list 3 1 4 1 5 9)) 3 5/6
Seed7
<lang 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;</lang>
Slate
<lang 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: {}.</lang>
Smalltalk
<lang smalltalk>| numbers | numbers := #(1 2 3 4 5 6 7 8). (numbers isEmpty ifTrue:[0]
ifFalse: [ (numbers inject: 0 into: [:sum :aNumber | sum + aNumber]) / numbers size ]
) displayNl.</lang>
SNOBOL4
<lang SNOBOL4> define('avg(a)i,sum') :(avg_end) avg i = i + 1; sum = sum + a :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 @p :s(loop)
empty = array(1) ;* Null vector
- # Test and display
output = '[' str '] -> ' avg(arr) output = '[ ] -> ' avg(empty)
end</lang>
Output:
[1 2 3 4 5 6 7 8 9 10] -> 5.5 [ ] -> 0.
Standard ML
These functions return a real:
<lang sml>fun mean_reals [] = 0.0
| mean_reals xs = foldl op+ 0.0 xs / real (length xs);
val mean_ints = mean_reals o (map real);</lang>
the previous code is easier to read and understand, though if you which
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.
<lang sml>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;</lang>
Tcl
<lang 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</lang>
TI-89 BASIC
<lang ti89b>Define rcmean(nums) = when(dim(nums) = 0, 0, mean(nums))</lang>
Trith
<lang trith>: mean dup empty? [drop 0] [dup [+] foldl1 swap length /] branch ;
[3 1 4 1 5 9] mean</lang>
UnixPipes
Caution: This solution overwrites the file named count in the current directory.
<lang 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 count | fold sum | xargs echo "scale=5;(1/" $(wc -l < count) ") * " | bc
}
(echo 3; echo 1; echo 4) | mean</lang>
UNIX Shell
This example uses expr, so it only works with integers. It checks that each string in the list is an integer.
<lang bash>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</lang>
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. <lang Ursala>#import nat
- import flo
mean = ~&?\0.! div^/plus:-0. float+ length
- cast %e
example = mean <5.,3.,-2.,6.,-4.></lang> output:
1.600000e+00
V
<lang v>[mean
[sum 0 [+] fold]. dup sum swap size [[1 <] [1]] when /
].</lang>
Vedit macro language
The numeric data is stored in current edit buffer as ASCII strings, one value per line. <lang vedit>#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)</lang>
Yorick
<lang yorick>func mean(x) {
if(is_void(x)) return 0; return x(*)(avg);
}</lang>
- Programming Tasks
- Probability and statistics
- 6502 Assembly
- ActionScript
- Ada
- ALGOL 68
- AmigaE
- AutoHotkey
- AWK
- APL
- BASIC
- BBC BASIC
- Befunge
- Befunge examples needing attention
- Examples needing attention
- Brainf***
- Brainf*** examples needing attention
- Brat
- C
- C sharp
- C++
- STL
- Chef
- Clojure
- Common Lisp
- D
- E
- Elena
- Erlang
- Euphoria
- Factor
- Fantom
- Forth
- Fortran
- F Sharp
- GAP
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- J
- Java
- JavaScript
- Functional
- Logo
- Lua
- Lucid
- M4
- Mathematica
- MATLAB
- MAXScript
- Nial
- Niue
- Objeck
- OCaml
- Octave
- Oz
- PARI/GP
- Perl
- Perl 6
- PHP
- PL/I
- PicoLisp
- Pop11
- PostScript
- Initlib
- PowerShell
- PureBasic
- Python
- R
- REBOL
- REXX
- Ruby
- Sather
- Scala
- Scheme
- Seed7
- Slate
- Smalltalk
- SNOBOL4
- Standard ML
- Tcl
- TI-89 BASIC
- Trith
- UnixPipes
- UNIX Shell
- Ursala
- V
- Vedit macro language
- Yorick