I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Averages/Arithmetic mean

(Redirected from Mean)
Averages/Arithmetic mean
You are encouraged to solve this task according to the task description, using any language you may know.
Task

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

## 0815

` {x{+=<:2:x/%<:d:~\$<:01:~><:02:~><:03:~><:04:~><:05:~><:06:~><:07:~><:08:~><:09:~><:0a:~><:0b:~><:0c:~><:0d:~><:0e:~><:0f:~><:10:~><:11:~><:12:~><:13:~><:14:~><:15:~><:16:~><:17:~><:18:~><:19:~><:ffffffffffffffff:~>{x{+>}:8f:{&={+>{~>&=x<:ffffffffffffffff:/#:8f:{{=<:19:x/% `
Output:
```0
D
```

## 11l

Translation of: Python
`F average(x)   R sum(x) / Float(x.len) print(average([0, 0, 3, 1, 4, 1, 5, 9, 0, 0]))`
Output:
```2.3
```

## 360 Assembly

Compact and functional.

`AVGP     CSECT         USING  AVGP,12         LR     12,15         SR     3,3                i=0         SR     6,6                sum=0LOOP     CH     3,=AL2(NN-T-1)     for i=1 to nn         BH     ENDLOOP         L      2,T(3)             t(i)         MH     2,=H'100'          scaling factor=2         AR     6,2                sum=sum+t(i)         LA     3,4(3)             next i         B      LOOPENDLOOP  LR     5,6                sum         LA     4,0         D      4,NN               sum/nn         XDECO  5,Z                edit binary          MVC    U,Z+10             descale         MVI    Z+10,C'.'         MVC    Z+11(2),U         XPRNT  Z,80               output         XR     15,15         BR     14T        DC     F'10',F'9',F'8',F'7',F'6',F'5',F'4',F'3',F'2',F'1'NN       DC     A((NN-T)/4)Z        DC     CL80' 'U        DS     CL2         END    AVGP`
Output:
`         5.50`

## 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-1AddLoop:		LDA (ArrayPtr),Y			CLC			ADC Temp			STA Temp			LDA Temp+1			ADC #0			STA Temp+1			DEY			CPY #255			BNE AddLoop 			LDY #-1DivideLoop:		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`

## 8th

` : avg \ a -- avg(a)  dup ' n:+ 0 a:reduce  swap a:len nip n:/ ; \ test:[ 1.0, 2.3, 1.1, 5.0, 3, 2.8, 2.01, 3.14159 ] avg . cr [ ] avg . cr[ 10 ] avg . crbye `

Output is:
2.54395
NaN
10.00000

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

## Action!

`INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit PROC Mean(INT ARRAY a INT count REAL POINTER result)  INT i  REAL x,sum,tmp   IntToReal(0,sum)  FOR i=0 TO count-1  DO    IntToReal(a(i),x)    RealAdd(sum,x,tmp)    RealAssign(tmp,sum)  OD  IntToReal(count,tmp)  RealDiv(sum,tmp,result)RETURN PROC Test(INT ARRAY a INT count)  INT i  REAL result   Mean(a,count,result)  Print("mean(")  FOR i=0 TO count-1  DO    PrintI(a(i))    IF i<count-1 THEN      Put(',)    FI  OD  Print(")=")  PrintRE(result)RETURN PROC Main()  INT ARRAY a1=[1 2 3 4 5 6]  INT ARRAY a2=[1 10 100 1000 10000]  INT ARRAY a3=[9]   Put(125) PutE() ;clear screen  Test(a1,6)  Test(a2,5)  Test(a3,1)  Test(a3,0)RETURN`
Output:
```mean(1,2,3,4,5,6)=3.5
mean(1,10,100,1000,10000)=2222.2
mean(9)=9
mean()=0
```

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

## Ada

This example shows how to pass a zero length vector as well as a larger vector. With Ada 2012 it is possible to check that pre conditions are satisfied (otherwise an exception is thrown). So we check that the length is not zero.

`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 with pre => Item'length > 0;   function Mean (Item : Vector) return Float is      Sum : Float := 0.0;   begin      for I in Item'range loop         Sum := Sum + Item(I);      end loop;	  return Sum / Float(Item'Length);   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

raised SYSTEM.ASSERTIONS.ASSERT_FAILURE : failed precondition from mean_main.adb:6

## Aime

`realmean(list l){    real sum, x;     sum = 0;    for (, x in l) {        sum += x;    }     sum / ~l;} integermain(void){    o_form("%f\n", mean(list(4.5, 7.25, 5r, 5.75)));     0;}`

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

## ALGOL W

`begin    % procedure to find the mean of the elements of a vector.                %    % As the procedure can't find the bounds of the array for itself,        %    % we pass them in lb and ub          %    real procedure mean ( real    array vector ( * )                        ; integer value lb                        ; integer value ub                        ) ;    begin        real sum;        assert( ub > lb ); % terminate the program if there are no elements  %        sum := 0;        for i := lb until ub do sum := sum + vector( i );        sum / ( ( ub + 1 ) - lb )    end mean ;     % test the mean procedure by finding the mean of 1.1, 2.2, 3.3, 4.4, 5.5 %    real array numbers ( 1 :: 5 );    for i := 1 until 5 do numbers( i ) := i + ( i / 10 );    r_format := "A"; r_w := 10; r_d := 2; % set fixed point output           %    write( mean( numbers, 1, 5 ) );end.`

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

## AntLang

AntLang has a built-in avg function.

`avg[list]`

## APL

Works with: APL2
`      X←3 1 4 1 5 9      (+/X)÷⍴X3.833333333`

## AppleScript

### Vanilla

With vanilla AppleScript, the process is the literal one of adding the numbers and dividing by the list length. It naturally returns results of class real, but it would be simple to return integer-representable results as integers if required.

`on average(listOfNumbers)    set len to (count listOfNumbers)    if (len is 0) then return missing value     set sum to 0    repeat with thisNumber in listOfNumbers        set sum to sum + thisNumber    end repeat     return sum / lenend average average({2500, 2700, 2400, 2300, 2550, 2650, 2750, 2450, 2600, 2400})`
Output:
`2530.0`

### ASObjC

The vanilla method above is the more efficient with lists of up to around 100 numbers. But for longer lists, using Foundation methods with AppleScriptObjectC can be useful

`use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or lateruse framework "Foundation" on average(listOfNumbers)    if ((count listOfNumbers) is 0) then return missing value     set arrayOfNumbers to current application's class "NSArray"'s arrayWithArray:(listOfNumbers)    return (arrayOfNumbers's valueForKeyPath:("@avg.self")) as realend average average({2500, 2700, 2400, 2300, 2550, 2650, 2750, 2450, 2600, 2400})`
Output:
`2530.0`

## Applesoft BASIC

`REM COLLECTION IN DATA STATEMENTS, EMPTY DATA IS THE END OF THE COLLECTION    0 READ V\$    1 IF LEN(V\$) = 0 THEN END    2 N = 0    3 S = 0    4 FOR I = 0 TO 1 STEP 0    5     S = S + VAL(V\$)    6     N = N + 1    7     READ V\$    8     IF LEN(V\$) THEN NEXT    9 PRINT S / N10000 DATA1,2,2.718,3,3.14263999 DATA REM COLLECTION IN AN ARRAY, ITEM 0 IS THE SIZE OF THE COLLECTIONA(0) = 5 : A(1) = 1 : A(2) = 2 : A(3) = 2.718 : A(4) = 3 : A(5) = 3.142N = A(0) : IF N THEN S = 0 : FOR I = 1 TO N : S = S + A(I) : NEXT : ? S / N `

## Arturo

`arr: [1 2 3 4 5 6 7] print average arr`
Output:
`4.0`

## Astro

`mean([1, 2, 3])mean(1..10)mean([]) `

## AutoHotkey

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

## AWK

`cat mean.awk#!/usr/local/bin/gawk -f # User defined functionfunction mean(v,      i,n,sum) {  for (i in v) {    n++    sum += v[i]  }  if (n>0) {    return(sum/n)  } else {    return("zero-length input !")  }} BEGIN {  # fill a vector with random numbers  for(i=0; i < 10; i++) {    vett[i] = rand()*10  }  print mean(vett)  print mean(nothing)} `
Output:
```\$ awk -f mean.awk
3.92689
zero-length input !
```

## Babel

`(3 24 18 427 483 49 14 4294 2 41) dup len <- sum ! -> / itod <<`
Output:
`535`

## BASIC

Works with: QBasic

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

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

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

### IS-BASIC

`100 NUMERIC ARR(3 TO 8)110 LET ARR(3)=3:LET ARR(4)=1:LET ARR(5)=4:LET ARR(6)=1:LET ARR(7)=5:LET ARR(8)=9120 PRINT AM(ARR)130 DEF AM(REF A)140   LET T=0150   FOR I=LBOUND(A) TO UBOUND(A)160     LET T=T+A(I)170   NEXT180   LET AM=T/SIZE(A)190 END DEF`

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

## 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< @./\\$_\&+\^`

## blz

` :mean(vec)    vec.fold_left(0, (x, y -> x + y)) / vec.length()end`

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

## Brat

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

## Burlesque

` blsq ) {1 2 2.718 3 3.142}av2.372blsq ) {}avNaN `

## BQN

Defines a tacit Avg function which works on any simple numeric list.

`Avg ← +´÷≠ Avg 1‿2‿3‿4`
`2.5`

## C

Compute mean of a `double` array of given length. If length is zero, does whatever `0.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

```

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

## 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);}`

## Chef

`Mean. Chef has no way to detect EOF, so rather than interpretingsome arbitrary number as meaning "end of input", this programexpects the first input to be the sample size. Pass in the samplesthemselves as the other inputs. For example, if you wanted tocompute the mean of 10, 100, 47, you could pass in 3, 10, 100, and47. To test the "zero-length vector" case, you need to pass in 0. Ingredients.0 g Sample Size0 g Counter0 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.`

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

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

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

## CoffeeScript

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

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

## Crystal

`# Crystal will return NaN if an empty array is passeddef mean(arr) : Float64  arr.sum / arr.size.to_fend`

## D

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

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

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

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

## dc

This is not a translation of the bc solution. Array handling would add some complexity. This one-liner is similar to the K solution.

`1 2 3 5 7 zsn1k[+z1<+]ds+xln/p3.6`

An expanded example, identifying an empty sample set, could be created as a file, e.g., amean.cd:

`[[Nada Mean: ]Ppq]sqzd0=qsn [stack length = n]sz1k [precision can be altered]sz[+z1<+]ds+x[Sum: ]Ppln/[Mean: ]Pp[Sample size: ]Plnp`

By saving the sample set "1 2 3 5 7" in a file (sample.dc), the routine, listing summary information, could be called in a command line:

`\$ dc sample.dc amean.cdSum: 18Mean: 3.6Sample size: 5\$`

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

## Dyalect

`func avg(args...) {    var acc = .0    var len = 0    for x in args {        len += 1        acc += x    }    acc / len} avg(1, 2, 3, 4, 5, 6)`

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

## EasyLang

`func mean . f[] r .  for i range len f[]    s += f[i]  .  r = s / len f[].f[] = [ 1 2 3 4 5 6 7 8 ]call mean f[] rprint r`

## EchoLisp

(mean values) is included in math.lib. values may be a list, vector, sequence, or any kind of procrastinator.

` (lib 'math)(mean '(1 2 3 4)) ;; mean of a list    → 2.5(mean #(1 2 3 4)) ;; mean of a vector    → 2.5 (lib 'sequences)(mean [1 3 .. 10]) ;; mean of a sequence    → 5 ;; error handling(mean 'elvis)    ⛔ error: mean : expected sequence : elvis(mean ())    💣 error: mean : null is not an object(mean #())    😐 warning: mean : zero-divide : empty-vector    → 0(mean [2 2 .. 2])    😁 warning: mean : zero-divide : empty-sequence    → 0 `

## ECL

` AveVal(SET OF INTEGER s) := AVE(s); //example usage SetVals := [14,9,16,20,91];AveVal(SetVals) //returns 30.0 ; `

## Elena

ELENA 5.0:

`import extensions; extension op{    average()    {        real sum := 0;        int count := 0;         var enumerator := self.enumerator();         while (enumerator.next())        {            sum += enumerator.get();            count += 1;        };         ^ sum / count    }} public program(){    var array := new int[]{1, 2, 3, 4, 5, 6, 7, 8};    console.printLine(        "Arithmetic mean of {",array.asEnumerable(),"} is ",        array.average()).readChar()}`
Output:
```Arithmetic mean of {1,2,3,4,5,6,7,8} is 4.5
```

## Elixir

`defmodule Average do  def mean(list), do: Enum.sum(list) / length(list)end`

## Emacs Lisp

`(defun mean (lst)  (/ (float (apply '+ lst)) (length lst)))(mean '(1 2 3 4))`
Library: Calc
`(let ((x '(1 2 3 4)))  (calc-eval "vmean(\$1)" nil (append '(vec) x)))`

## Erlang

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

## 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 ifend function sequence testtest = {1.0, 2.0, 5.0, -5.0, 9.5, 3.14159}? mean(test)`

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

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

## Factor

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

Tests:

`( scratchpad ) { 2 3 5 } arithmetic-mean >float3.333333333333333`

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

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

## Forth

`: fmean ( addr n -- f )  0e  dup 0= if 2drop exit then  tuck floats bounds do    i [email protected] 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`

## 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 arrayreal :: mean, zmean, bmeanreal, dimension(20) :: colmeansreal, dimension(5) :: rowmeans mean = sum(a)/size(a)                ! SUM of A's elements divided by SIZE of Amean = 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)`

## FreeBASIC

` ' FB 1.05.0 Win64 Function Mean(array() As Double) As Double  Dim length As Integer = Ubound(array) - Lbound(array) + 1  If length = 0 Then    Return 0.0/0.0 'NaN  End If  Dim As Double sum = 0.0  For i As Integer = LBound(array) To UBound(array)    sum += array(i)  Next  Return sum/lengthEnd Function Function IsNaN(number As Double) As Boolean  Return Str(number) = "-1.#IND" ' NaN as a string in FBEnd Function Dim As Integer n, iDim As Double numPrint "Sample input and output"PrintDo  Input "How many numbers are to be input ? : ", nLoop Until n > 0Dim vector(1 To N) As DoublePrintFor i = 1 to n  Print "  Number #"; i; " : ";  Input "", vector(i)NextPrintPrint "Mean is"; Mean(vector())PrintErase vectornum = Mean(vector())If IsNaN(num) Then  Print "After clearing the vector, the mean is 'NaN'"End IfPrintPrint "Press any key to quit the program"Sleep `
Output:
```Sample input and output

How many numbers are to be input ? : 6

Number # 1 : 12
Number # 2 : 18
Number # 3 : 5.6
Number # 4 : 6
Number # 5 : 23
Number # 6 : 17

Mean is 13.6

After clearing the vector, the mean is 'NaN'
```

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

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

## GEORGE

`R (n) P ;01, n rep (i)   R P +]n divP`

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

## GFA Basic

This works for arrays of integers.

` DIM a%(10)FOR i%=0 TO 10  a%(i%)=i%*2  PRINT "element ";i%;" is ";a%(i%)NEXT i%PRINT "mean is ";@mean(a%)'FUNCTION mean(a%)  LOCAL i%,size%,sum  ' find size of array,  size%=DIM?(a%())  ' return 0 for empty arrays  IF size%<=0    RETURN 0  ENDIF  ' find sum of all elements  sum=0  FOR i%=0 TO size%-1    sum=sum+a%(i%)  NEXT i%  ' mean is sum over size  RETURN sum/size%ENDFUNC `

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

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

## Haskell

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

`mean :: (Fractional a) => [a] -> amean [] = 0mean 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] -> bmeanReals = 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] -> mmean xs =  let (s, l) =        foldl' --'          f          (0, 0)          xs  in realToFrac s / l  where    f (!s, !l) x = (s + x, l + 1) main :: IO ()main = print \$ mean [1 .. 100]`

## HicEst

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

## Hy

Returns None if the input is of length zero.

`(defn arithmetic-mean [xs]    (if xs        (/ (sum xs) (len xs))))`

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

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

## 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 93.83333   mean \$0         NB. \$0 is a zero-length vector0   x=: 20 4 [email protected]\$ 0  NB. a 20-by-4 table of random (0,1) numbers   mean x0.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 93.83333   mean1 \$00   mean1 x0.58243 0.402948 0.477066 0.511155`

## Java

Works with: Java version 1.5+
`public static double avg(double... arr) {    double sum = 0.0;    for (double x : arr) {        sum += x;    }    return sum / arr.length;}`

## JavaScript

### ES5

`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] ) );   // 3alert( mean( [] ) );            // 0`

Using the native function `.forEach()`:

`function mean(array) {    var sum = 0;    array.forEach(function(value){        sum += value;        });    return array.length ? sum / array.length : 0;    } alert( mean( [1,2,3,4,5] ) );   // 3`

Using the native function `.reduce()`:

`function mean(array) {    return !array.length ? 0        : array.reduce(function(pre, cur, i) {            return (pre * i + cur) / (i + 1);            });    } alert( mean( [1,2,3,4,5] ) );   // 3alert( mean( [] ) );            // 0 `

Extending the `Array` prototype:

`Array.prototype.mean = function() {    return !this.length ? 0        : this.reduce(function(pre, cur, i) {            return (pre * i + cur) / (i + 1);            });    } alert( [1,2,3,4,5].mean() );   // 3alert( [].mean() );            // 0 `

Library: Functional
`function mean(a){ return a.length ? Functional.reduce('+', 0, a) / a.length : 0;}`

### ES6

`(sample => {     // mean :: [Num] => (Num | NaN)    let mean = lst => {        let lng = lst.length;         return lng ? (            lst.reduce((a, b) => a + b, 0) / lng        ) : NaN;    };     return mean(sample); })([1, 2, 3, 4, 5, 6, 7, 8, 9]);`
Output:
`5`

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

## Julia

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

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

## K

`  mean: {(+/x)%#x}  mean 1 2 3 5 73.6  [email protected]!0    / empty array0.0`

## Kotlin

Kotlin has builtin functions for some collection types. Example:

`fun main(args: Array<String>) {    val nums = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)    println("average = %f".format(nums.average()))}`

## KQL

` let dataset = datatable(values:real)[                        1,      1.5,    3,  5,      6.5]; dataset|summarize avg(values)  `

Output:

```
avg_values
3.4
```

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

## Lambdatalk

` {def mean {lambda {:s}  {if {S.empty? :s}   then 0   else {/ {+ :s} {S.length :s}}}}} {mean {S.serie 0 1000}}-> 500 `

## langur

The built-in mean() function works with an array, hash, or range of numbers.

We could use fold() to write a function that takes an array and calculates the mean.

Works with: langur version 0.6.6
`val .mean = f(.x) fold(f{+}, .x) / len(.x) writeln "  custom: ", .mean([7, 3, 12])writeln "built-in: ", mean([7, 3, 12])`
Output:
```  custom: 7.333333333333333333333333333333333
built-in: 7.333333333333333333333333333333333```

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

## LFE

### 1-Arity

` (defun mean (data)  (/ (lists:sum data)     (length data))) `

Usage:

`> (mean '(1 1))1.0> (mean '(1 2))1.5> (mean '(2 10))6.0> (mean '(6 12 18 24 30 36 42 48 54 60 66 72 78))42.0`

### n-Arity

Functions in LFE (and Erlang) have set arity, but macros can be used to provide the same use as n-arity functions:

`(defmacro mean args  `(/ (lists:sum ,args)      ,(length args)))`

Usage:

`> (mean 42)42.0> (mean 18 66)42.0> (mean 6 12 18 24 30 36 42 48 54 60 66 72 78)42.0`

## Liberty BASIC

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

## Limbo

`implement Command; include "sys.m";sys: Sys; include "draw.m"; include "sh.m"; init(nil: ref Draw->Context, nil: list of string){	sys = load Sys Sys->PATH; 	a := array[] of {1.0, 2.0, 500.0, 257.0};	sys->print("mean of a: %f\n", getmean(a));} getmean(a: array of real): real{	n: real = 0.0;	for (i := 0; i < len a; i++)		n += a[i];	return n / (real len a);}`

## Lingo

`-- v can be (2D) point, (3D) vector or list of integers/floatson mean (v)    case ilk(v) of        #point: cnt = 2        #vector: cnt = 3        #list: cnt = v.count        otherwise: return    end case    sum = 0    repeat with i = 1 to cnt        sum = sum + v[i]    end repeat    return float(sum)/cntend`
`put mean(point(1, 2.5))-- 1.7500put mean(vector(1.2, 4.7, 5.6))-- 3.8333put mean([6,12,18,24,30,36,42,48,54,60,66,72,78])-- 42.0000`

## LiveCode

Livecode provides arithmeticMean (avg, average) built-in.

`average(1,2,3,4,5)  -- 3average(empty)  -- 0`

## Logo

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

## 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.5yes `

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

## 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 / #numlistend print (mean({3,1,4,1,5,9}))`

## Lucid

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

## 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)')dnldefine(`fmean', `eval(`(\$2/\$1)/100').extractdec(eval(`\$2/\$1'))')dnldefine(`mean', `rmean(`\$#', [email protected])')dnldefine(`rmean', `ifelse(`\$3', `', `fmean(\$1,\$2)',dnl`rmean(\$1, eval(\$2+\$3), shift(shift(shift([email protected]))))')')dnl`
`mean(0,100,200,300,400,500,600,700,800,900,1000)`

## 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 raisedError, (in mean) numeric exception: division by zero `

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

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

## Mathematica / Wolfram Language

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):

`44.53333-1.3835077/2401/5 (-3+2 a+c+Pi)`

## 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.47Parameter(s) specified in the command line: --nopresol --math AM.mprogReading model section from AM.mprog...24 lines were readGenerating zumVariance...Generating variances...Model has been successfully generatedScaling... A: min|aij| = 1.000e+000  max|aij| = 1.000e+000  ratio = 1.000e+000Problem data seem to be well scaledConstructing initial basis...Size of triangular part = 1048575GLPK Simplex Optimizer, v4.471048576 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 FOUNDTime used:   2.0 secsMemory used: 1393.8 Mb (1461484590 bytes)The arithmetic mean of the integers from 1 to 1048575 is 524288.000000Model has been successfully processed `

## MATLAB

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

## Maxima

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

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

## Mercury

`:- module arithmetic_mean.:- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module float, list, require. main(!IO) :-    io.print_line(mean([1.0, 2.0, 3.0, 4.0, 5.0]), !IO). :- func mean(list(float)) = float. mean([]) = func_error("mean: emtpy list").mean(Ns @ [_ | _]) = foldl((+), Ns, 0.0) / float(length(Ns)). :- end_module arithmetic_mean.`

Alternatively, we could use inst subtyping to ensure we get a compilation error if the mean function is called with an empty list.

`:- func mean(list(float)::in(non_empty_list)) = (float::out). mean(Ns) = foldl((+), Ns, 0.0) / float(length(Ns)).`

## min

Returns `nan` for an empty quotation.

Works with: min version 0.19.3
`(((0 (+) reduce) (size /)) cleave) :mean(2 3 5) mean print`
Output:
```3.333333333333334
```

## MiniScript

`arr = [ 1, 3, 7, 8, 9, 1 ] avg = function(arr)    avgNum = 0    for num in arr        avgNum = avgNum + num    end for    return avgNum / arr.lenend function print avg(arr)`

## МК-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.

## Modula-2

`PROCEDURE  Avg; VAR     avg             : REAL; BEGIN   avg := sx / n;   InOut.WriteString ("Average = ");   InOut.WriteReal (avg, 8, 2);   InOut.WriteLnEND 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;`

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

## Nanoquery

`def sum(lst)        sum = 0        for n in lst                sum += n        end        return sumend def average(x)        return sum(x) / len(x)end`

## 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]));    }}`

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

```

## NewLISP

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

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

## Nim

Translation of: C
`import strutils proc mean(xs: openArray[float]): 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)  if v.len > 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 = -1.#IND```

## 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 .=> 33.4 2.3 .01 2.0 2.1 avg .=> 1.9619999999999997 `

## 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.LnEND AvgMean. `

Output:

```14.55
```

## Objeck

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

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

## 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);  endifendfunction 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;`

## Oforth

`: avg ( x -- avg )   x sum    x size dup ifZero: [ 2drop null ] else: [ >float / ];`
Output:
```[1, 2, 2.718, 3, 3.142] avg .
2.372 ok
[ ] avg .
null ok
```

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

## 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.]}}`

## PARI/GP

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

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

## Perl

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

## Phix

```with javascript_semantics
function mean(sequence s)
if length(s)=0 then return 0 end if
return sum(s)/length(s)
end function

? mean({1, 2, 5, -5, -9.5, 3.14159})
```

## Phixmonti

`1 2 5 -5 -9.5 3.14159 stklen tolistlen swap sum swap / print`

## PHP

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

## PicoLisp

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

Output:

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

## PL/I

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

## Plain English

`To run:Start up.Demonstrate finding the arithmetic mean.Wait for the escape key.Shut down. An entry is a thing with a fraction.A list is some entries.A sum is a fraction.A mean is a fraction. To demonstrate finding the arithmetic mean:Create an example list.Write "A list: " then the example list on the console.Find a mean of the example list.Write "The list's mean: " then the mean on the console.Destroy the example list. To add a fraction to a list:Allocate memory for an entry.Put the fraction into the entry's fraction.Append the entry to the list. To create an example list:Add 1/1 to the example list.Add 2/1 to the example list.Add 5-1/3 to the example list.Add 7-1/2 to the example list. To find a sum of a list:Put 0 into the sum.Get an entry from the list.Loop.If the entry is nil, exit.Add the entry's fraction to the sum.Put the entry's next into the entry.Repeat. To find a mean of a list:Find a sum of the list.Put the sum divided by the list's count into the mean. To convert a list to a string:Get an entry from the list.Loop.If the entry is nil, break.Append the entry's fraction to the string.If the entry's next is not nil, append ", " to the string.Put the entry's next into the entry.Repeat.`
Output:
```A list: 1, 2, 5-1/3, 7-1/2
The list's mean: 3-23/24
```

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

## PostScript

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

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

## Processing

`float mean(float[] arr) {  float out = 0;  for (float n : arr) {    out += n;  }  return out / arr.length;}`

## Prolog

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

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

## 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 fsumdef average(x):    return fsum(x)/float(len(x)) if x else 0print (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.32.3`

Works with: Python version 2.5
`def average(x):    return sum(x)/float(len(x)) if x else 0print (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.31e-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`
Works with: Python version 3.4

Since 3.4, Python has a [statistics library in the stdlib, which takes care of these precision overflow issues in a way that works for all standard types, not just float, even with values way too big or small to fit in a float. (For Python 2.6-2.7, there's a backport available on PyPI.)

`>>> from statistics import mean>>> mean([1e20,-1e-20,3,1,4,1,5,9,-1e20,1e-20])2.3>>> mean([10**10000, -10**10000, 3, 1, 4, 1, 5, 9, 0, 0])2.3>>> mean([10**10000, -10**10000, 3, 1, 4, 1, 5, 9, Fraction(1, 10**10000), Fraction(-1, 10**10000)])Fraction(23, 10)>>> big = 10**10000>>> mean([Decimal(big), Decimal(-big), 3, 1, 4, 1, 5, 9, 1/Decimal(big), -1/Decimal(big)])Decimal('2.3')`

## Q

A built-in solution is avg. An implementation of it could be:

`mean:{(sum x)%count x}`

## Quackery

Using the Quackery big number rational arithmetic library `bigrat.qky`.

`  [ \$ 'bigrat.qky' loadfile ] now!   [ [] swap times    [ 20001 random 10000 -      n->v 100 n->v v/      join nested join ] ]   is makevector   (   --> [   )   [ witheach       [ unpack         2 point\$ echo\$        i 0 > if           [ say ", " ] ] ]   is echodecs      ( [ -->     )   [ dup size n->v rot    0 n->v rot    witheach       [ unpack v+ ]    2swap v/ ]               is arithmean    ( [ --> n/d )   [ 5 makevector       say "Internal representation of a randomly generated vector" cr    say "of five rational numbers. They are distributed between" cr    say "-100.00 and +100.00 and are multiples of 0.01."    cr cr dup echo cr cr    say "Shown as decimal fractions."    cr cr dup echodecs cr cr     arithmean     say "Arithmetic mean of vector as a decimal fraction to" cr     say "5 places after the point, as a rounded proper" cr    say "fraction with the denominator not exceeding 10, and" cr    say "finally as a vulgar fraction without rounding." cr cr    2dup 5 point\$ echo\$    say ", "    2dup proper 10 round improper    proper\$ echo\$    say ", "    vulgar\$ echo\$ cr cr     say "The same, but with a vector of 9973 rational numbers," cr    say "20 decimal places and a denominator not exceeding 100." cr cr     9973 makevector arithmean     2dup 20 point\$ echo\$    say ", "    2dup proper 100 round improper    proper\$ echo\$    say ", "    vulgar\$ echo\$ cr ]       is demonstrate  (   -->     )`
Output:
```Internal representation of a randomly generated vector
of five rational numbers. They are distributed between
-100.00 and +100.00 and are multiples of 0.01.

[ [ -1999 100 ] [ 253 50 ] [ 2867 50 ] [ 3929 50 ] [ -25 2 ] ]

Shown as decimal fractions.

-19.99, 5.06, 57.34, 78.58, -12.5

Arithmetic mean of vector as a decimal fraction to
5 places after the point, as a rounded proper
fraction with the denominator not exceeding 10, and
finally as a vulgar fraction without rounding.

21.698, 21 7/10, 10849/500

The same, but with a vector of 9973 rational numbers,
20 decimal places and a denominator not exceeding 100.

-0.41664995487817106187, -0 5/12, -16621/39892```

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

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

## Raku

(formerly Perl 6)

Works with: Rakudo version 2015.10-11
`multi mean([]){ Failure.new('mean on empty list is not defined') }; # Failure-objects are lazy exceptionsmulti mean (@a) { ([+] @a) / @a }`

## REBOL

`rebol [    Title: "Arithmetic Mean (Average)"    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```

## Red

Red comes with the `average` function.

`Red ["Arithmetic mean"] print average []print average [2 3 5]`
Output:
```none
3.333333333333334
```

The source code for `average`:

`average: func [    "Returns the average of all values in a block"     block [block! vector! paren! hash!]][    if empty? block [return none]     divide sum block to float! length? block]`

## ReScript

`let arr = [3, 8, 4, 1, 5, 12] let num = Js.Array.length(arr)let tot = Js.Array.reduce(\"+", 0, arr)let mean = float_of_int(tot) /. float_of_int(num) Js.log(Js.Float.toString(mean))`
Output:
```\$ bsc arithmean.res > arithmean.js
\$ node arithmean.js
5.5
```

## REXX

The vectors (list) can contain any valid (REXX) numbers.

A check is made to validate if the numbers in the list are all numeric.

`/*REXX program finds the averages/arithmetic mean of several lists (vectors) or CL input*/parse arg @.1; if @.1=''  then do;   #=6                         /*vector from the C.L.?*/                               @.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 =                             /*  ◄─── a null value. */                               end                          else #=1                               /*number of CL vectors.*/     do j=1  for #     say '       numbers = '   @.j     say '       average = '   avg(@.j)     say copies('═', 79)     end   /*t*/exit                                             /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/avg: procedure;  parse arg x;     #=words(x)                      /*#:  number of items.*/     if #==0  then return  'N/A: ───[null vector.]'               /*No words? Return N/A*/     \$=0          do k=1  for #;      _=word(x,k)                         /*obtain a number.    */          if datatype(_,'N')  then do;  \$=\$+_;  iterate;   end    /*if numeric, then add*/          say left('',40) "***error***  non-numeric: " _;  #=#-1  /*error; adjust number*/          end   /*k*/      if #==0  then return  'N/A: ───[no numeric values.]'         /*No nums?  Return N/A*/     return \$ / #                                                 /*return the average. */`

output   when using the (internal) lists:

```       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.]
═══════════════════════════════════════════════════════════════════════════════

```

## Ring

` nums = [1,2,3,4,5,6,7,8,9,10]sum = 0see "Average = " + average(nums) + nl func average numbers     for i = 1 to len(numbers)         sum = sum + nums[i]     next     return sum/len(numbers) `

## RPL/2

This is a simple rewrite of the dc version above. This works on an HP 48. "->" is a single right arrow character on the 48. Feel free to alter this code as necessary to work on RPL/2.

`1 2 3 5 7AMEAN   << DEPTH DUP 'N' STO ->LIST ΣLIST N / >>3.6`

## Ruby

`def mean(nums)  nums.sum(0.0) / nums.sizeend 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
```

## Run BASIC

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

## Rust

`fn sum(arr: &[f64]) -> f64 {    arr.iter().fold(0.0, |p,&q| p + q)} fn mean(arr: &[f64]) -> f64 {    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```

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

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

## Scheme

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

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

## SenseTalk

SenseTalk has a built-in average function.

`put the average of [12,92,-17,66,128] put average(empty) `
Output:
```56.2
nan
```

## Sidef

`func avg(Array list) {    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```

## 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: {}.`

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

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

## SQL

Tested on Oracle 11gR2, the more limited the tool, the more resourceful one becomes :)

` CREATE TABLE "numbers" ("datapoint" INTEGER); INSERT INTO "numbers" SELECT rownum FROM tab; SELECT SUM("datapoint")/COUNT(*)  FROM "numbers"; `

...or...

`SELECT avg("datapoint") FROM "numbers";`

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

## Stata

### Mean of a dataset variable

Illustration of the mean on the population (in millions) in january 2016 of a few european countries (source Eurostat).

`clear allinput str20 country populationBelgium 11311.1Bulgaria 7153.8"Czech Republic" 10553.8Denmark 5707.3Germany 82175.7Estonia 1315.9Ireland 4724.7Greece 10783.7end . mean population Mean estimation                   Number of obs   =          8 --------------------------------------------------------------             |       Mean   Std. Err.     [95% Conf. Interval]-------------+------------------------------------------------  population |   16715.75   9431.077     -5585.203     39016.7-------------------------------------------------------------- . tabstat population, statistic(mean)    variable |      mean-------------+----------  population |  16715.75------------------------ . quietly summarize population. display r(mean)16715.75`

### Mean in Mata

`mataa=11311.1\7153.8\10553.8\5707.3\82175.7\1315.9\4724.7\10783.7 mean(a)16715.75`

## Swift

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

## Tcl

`package require Tcl 8.5proc 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`

## TI-83 BASIC

`Mean(Ans`

## TI-89 BASIC

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

## Trith

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

## TypeScript

` function mean(numbersArr){    let arrLen = numbersArr.length;    if (arrLen > 0) {        let sum: number = 0;        for (let i of numbersArr) {            sum += i;        }        return sum/arrLen;    }    else return "Not defined";} alert( mean( [1,2,3,4,5] ) );   alert( mean( [] ) );         `

## UNIX Shell

1) First solution with bash (V >= 3), works with floats :

`echo "`cat f | paste -sd+ | bc -l` / `cat f | wc -l`" | bc -l `
`cat f124816-200 echo "`cat f | paste -sd+ | bc -l`/`cat f | wc -l`" | bc -l-28.16666666666666666666 cat f1.10943424.58.4516-200400.56 echo "`cat f | paste -sd+ | bc -l`/`cat f | wc -l`" |bc -l33.23134771428571428571 `

2) 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				# 0printf "test 2: "; mean 300			# 300printf "test 3: "; mean 300 100 400		# 266printf "test 4: "; mean -400 400 -1300 200	# -275printf "test 5: "; mean -			# expr: syntax errorprintf "test 6: "; mean 1 2 A 3			# expr: non-numeric argument`

## UnixPipes

 This example is incorrect. Please fix the code and remove this message.Details: 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.

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`

## Ursa

`## arithmetic mean# decl int<> inputdecl int ifor (set i 1) (< i (size args)) (inc i)        append (int args<i>) inputend for out (/ (+ input) (size input)) endl console`

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

## V

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

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

## VBA

`Private Function mean(v() As Double, ByVal leng As Integer) As Variant    Dim sum As Double, i As Integer    sum = 0: i = 0    For i = 0 To leng - 1        sum = sum + vv    Next i    If leng = 0 Then        mean = CVErr(xlErrDiv0)    Else        mean = sum / leng    End IfEnd FunctionPublic Sub main()    Dim v(4) As Double    Dim i As Integer, leng As Integer    v(0) = 1#    v(1) = 2#    v(2) = 2.178    v(3) = 3#    v(4) = 3.142    For leng = 5 To 0 Step -1        Debug.Print "mean[";        For i = 0 To leng - 1            Debug.Print IIf(i, "; " & v(i), "" & v(i));        Next i        Debug.Print "] = "; mean(v, leng)    Next lengEnd Sub`
Output:
```mean[1; 2; 2,178; 3; 3,142] =  0
mean[1; 2; 2,178; 3] =  0
mean[1; 2; 2,178] =  0
mean[1; 2] =  0
mean[1] =  0
mean[] = Fout 2007```

## VBScript

` Function mean(arr)	size = UBound(arr) + 1	mean = 0	For i = 0 To UBound(arr)		mean = mean + arr(i)	Next	mean = mean/sizeEnd Function 'ExampleWScript.Echo mean(Array(3,1,4,1,5,9)) `
Output:
`3.83333333333333`

## Vedit macro language

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

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

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

## Wart

`def (mean l)  sum.l / len.l`

Example run:

```mean '(1 2 3)
=> 2```

## WDTE

`let s => import 'stream';let a => import 'arrays'; let mean nums =>  a.stream nums  -> s.reduce [0; 0] (@ s p n => [+ (a.at p 0) 1; + (a.at p 1) n])  -> (@ s p => / (a.at p 1) (a.at p 0));`

This is a tad messier than it has to be due to a lack of a way to get the length of an array in WDTE currently.

Usage:

`mean [1; 2; 3] -- io.writeln io.stdout;`

Output:

`2`

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

## Wren

`class Arithmetic {    static mean(arr) {        if (arr.count == 0) Fiber.abort("Length must be greater than zero")        return arr.reduce(Fn.new{ |x,y| x+y }) / arr.count    }}Arithmetic.mean([1,2,3,4,5]) // 3`

## XLISP

The specification calls for a function that takes a vector; for convenience, we convert this vector internally to a list. The mean of a zero-length vector is returned as nil, equivalent to the empty list or logical false.

`(defun mean (v)    (if (= (vector-length v) 0)        nil        (let ((l (vector->list v)))            (/ (apply + l) (length l)))))`

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

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

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

## Yorick

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

## zkl

Converts int to floats (implicitly):

`fcn mean(a,b,c,etc){ z:=vm.arglist; z.reduce('+,0.0)/z.len() }mean(3,1,4,1,5,9);  //-->3.83333mean(); //-->Exception thrown: MathError(NaN (Not a number))`

To pass in a vector/list:

`fcn meanV(z){ z.reduce('+,0.0)/z.len() }meanV(T(3,1,4,1,5,9)); // --> 3.83333`

## Zoea

` program: average  case: 1    input: [2,3,10]    output: 5  case: 2    input: [7,11]    output: 9    `

## zonnon

` module Averages;type 	Vector = array {math} * of real; 	procedure ArithmeticMean(x: Vector): real;	begin		(* sum is a predefined function for mathematical arrays *)		return sum(x)	end ArithmeticMean;var	x: Vector; begin	x := new Vector(4);	x := [1.0, 2.3, 3.2, 2.1, 5.3];	write("arithmetic mean: ");writeln(ArithmeticMean(x):10:2)end Averages. `
Output:
```arithmetic mean:       13,9
```