Averages/Arithmetic mean: Difference between revisions
→{{header|langur}}
(→{{header|BBC BASIC}}: Added bc) |
Langurmonkey (talk | contribs) |
||
(198 intermediate revisions by more than 100 users not shown) | |||
Line 1:
{{task|Probability and statistics}}
;Task
Write a program to find the [[wp:arithmetic mean|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.
{{task heading|See also}}
{{Related tasks/Statistical measures}}
<br><hr>
=={{header|0815}}==
<syntaxhighlight lang="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/%
</syntaxhighlight>
{{out}}
<pre>
0
D
</pre>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F average(x)
R sum(x) / Float(x.len)
print(average([0, 0, 3, 1, 4, 1, 5, 9, 0, 0]))</syntaxhighlight>
{{out}}
<pre>
2.3
</pre>
=={{header|360 Assembly}}==
Compact and functional.
<syntaxhighlight lang="360asm">AVGP CSECT
USING AVGP,12
LR 12,15
SR 3,3 i=0
SR 6,6 sum=0
LOOP 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 LOOP
ENDLOOP 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 14
T 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</syntaxhighlight>
{{out}}
<pre> 5.50</pre>
=={{header|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.
<
TYA
PHA ;push accumulator and Y register onto stack
Line 45 ⟶ 111:
TAY
PLA
RTS ;return from routine</
=={{header|8th}}==
<syntaxhighlight lang="forth">
: 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 . cr
bye
</syntaxhighlight>
Output is:<br>
2.54395<br>
NaN<br>
10.00000
=={{header|ACL2}}==
<
(if (endp xs)
(mv 0 0)
Line 60 ⟶ 143:
(mv-let (n d)
(mean-r xs)
(/ n d))))</
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Arithmetic_mean.png Screenshot from Atari 8-bit computer]
<pre>
mean(1,2,3,4,5,6)=3.5
mean(1,10,100,1000,10000)=2222.2
mean(9)=9
mean()=0
</pre>
=={{header|ActionScript}}==
<
{
var sum:Number = 0;
Line 69 ⟶ 208:
sum += vector[i];
return vector.length == 0 ? 0 : sum / vector.length;
}</
=={{header|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.Text_IO; use Ada.Text_IO;
procedure Mean_Main is
type Vector is array (Positive range <>) of Float;
function Mean (Item : Vector) return
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 /
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:
raised SYSTEM.ASSERTIONS.ASSERT_FAILURE : failed precondition from mean_main.adb:6
=={{header|Aime}}==
<syntaxhighlight lang="aime">real
mean(list l)
{
real sum, x;
sum = 0;
for (, x in l) {
sum += x;
}
sum / ~l;
}
integer
main(void)
{
o_form("%f\n", mean(list(4.5, 7.25, 5r, 5.75)));
0;
}</syntaxhighlight>
=={{header|ALGOL 68}}==
{{trans|C}}
Line 107 ⟶ 267:
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
{{works with|ELLA ALGOL 68|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.}}
<
# Calculates the mean of qty REALs beginning at p. #
IF LWB p > UPB p THEN 0.0
Line 119 ⟶ 279:
[6]REAL test := (1.0, 2.0, 5.0, -5.0, 9.5, 3.14159);
print((mean(test),new line))
)</
=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">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.</syntaxhighlight>
=={{header|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")
<
DEF m, i, ll
ll := ListLen(l)
Line 137 ⟶ 321:
WriteF('mean \s\n',
RealF(s,mean([1.0, 2.0, 3.0, 4.0, 5.0]), 2))
ENDPROC</
=={{header|AntLang}}==
AntLang has a built-in avg function.
<syntaxhighlight lang="antlang">avg[list]</syntaxhighlight>
=={{header|APL}}==
{{works with|APL2}}
<syntaxhighlight lang="apl">
X←3 1 4 1 5 9
(+/X)÷⍴X
3.833333333
</syntaxhighlight>
{{works with|Dyalog APL}}
A proper function definition:
<syntaxhighlight lang="apl">
Avg←{(+⌿⍵)÷≢⍵}
Avg 1 2 3 4 5 6
3.5
</syntaxhighlight>
Using [[tacit programming]]:
<syntaxhighlight lang="apl">
Avg← +⌿÷≢
Avg 1 2 3 4 5 6
3.5
</syntaxhighlight>
'''N.B.:''' the symbol for [https://aplwiki.com/wiki/Tally Tally (≢)] doesn't display correctly on Chrome-based browsers at the moment.
=={{header|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.
<syntaxhighlight lang="applescript">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 / len
end average
average({2500, 2700, 2400, 2300, 2550, 2650, 2750, 2450, 2600, 2400})</syntaxhighlight>
{{output}}
<pre>2530.0</pre>
===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
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use 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 real
end average
average({2500, 2700, 2400, 2300, 2550, 2650, 2750, 2450, 2600, 2400})</syntaxhighlight>
{{output}}
<pre>2530.0</pre>
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="applesoftbasic">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 / N
10000 DATA1,2,2.718,3,3.142
63999 DATA
REM COLLECTION IN AN ARRAY, ITEM 0 IS THE SIZE OF THE COLLECTION
A(0) = 5 : A(1) = 1 : A(2) = 2 : A(3) = 2.718 : A(4) = 3 : A(5) = 3.142
N = A(0) : IF N THEN S = 0 : FOR I = 1 TO N : S = S + A(I) : NEXT : ? S / N
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">arr: [1 2 3 4 5 6 7]
print average arr</syntaxhighlight>
{{out}}
<pre>4.0</pre>
=={{header|Astro}}==
<syntaxhighlight lang="astro">mean([1, 2, 3])
mean(1..10)
mean([])
</syntaxhighlight>
=={{header|AutoHotkey}}==
<
Loop, % i {
Random, v, -3.141592, 3.141592
Line 146 ⟶ 435:
sum += v
}
MsgBox, % i ? list "`nmean: " sum/i:0</
=={{header|AWK}}==
<syntaxhighlight lang="awk">cat mean.awk
#!/usr/local/bin/gawk -f
# User defined function
function mean(v, i,n,sum) {
sum += v[i]
}
if (n>0) {
return(sum/n)
} else {
return("zero-length input !")
}
}
Line 175 ⟶ 460:
}
print mean(vett)
print mean(nothing)
}
</syntaxhighlight>
<pre>
$ awk -f mean.awk
3.92689
zero-length input !
</pre>
=={{header|Babel}}==
<syntaxhighlight lang="babel">(3 24 18 427 483 49 14 4294 2 41) dup len <- sum ! -> / itod <<</syntaxhighlight>
{{Out}}
<pre>535</pre>
=={{header|BASIC}}==
Line 204 ⟶ 482:
Assume the numbers are in an array named "nums".
<
sum = 0;
FOR i = LBOUND(nums) TO UBOUND(nums)
Line 215 ⟶ 493:
ELSE
PRINT 0
END IF</
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
To calculate the mean of an array:
<syntaxhighlight lang="bbc basic">
REM specific functions for the array/vector types
Line 250 ⟶ 528:
DEF FN_Mean_Arithmetic#(n#())
= SUM(n#()) / (DIM(n#(),1)+1)
</syntaxhighlight>
[[User:MichaelHutton|Michael Hutton]] 14:02, 29 May 2011 (UTC)
==={{header|IS-BASIC}}===
<syntaxhighlight lang="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)=9
120 PRINT AM(ARR)
130 DEF AM(REF A)
140 LET T=0
150 FOR I=LBOUND(A) TO UBOUND(A)
160 LET T=T+A(I)
170 NEXT
180 LET AM=T/SIZE(A)
190 END DEF</syntaxhighlight>
=={{header|bc}}==
Uses the current scale for calculating the mean.
<
auto i, s
Line 262 ⟶ 552:
}
return(s / n)
}</
=={{header|Befunge}}==
The first input is the length of the vector. If a length of 0 is entered, the result is equal to <code>0/0</code>.
<syntaxhighlight lang="befunge">&:0\:!v!:-1<
@./\$_\&+\^</syntaxhighlight>
=={{header|blz}}==
<syntaxhighlight lang="blz">
:mean(vec)
vec.fold_left(0, (x, y -> x + y)) / vec.length()
end</syntaxhighlight>
=={{header|Bracmat}}==
Here are two solutions. The first uses a while loop, the second scans the input by backtracking.
<
(mean1=
sum length n
Line 299 ⟶ 592:
| !sum*!length^-1
);
</syntaxhighlight>
To test with a list of all numbers 1 .. 999999:
<
( :?test
& 1000000:?Length
Line 307 ⟶ 600:
& out$mean1$!test
& out$mean2$!test
)</
=={{header|Brat}}==
<
true? list.empty?, 0, { list.reduce(0, :+) / list.length }
}
p mean 1.to 10 #Prints 5.5</
=={{header|Burlesque}}==
<
blsq ) {1 2 2.718 3 3.142}av
2.372
blsq ) {}av
NaN
</syntaxhighlight>
=={{header|BQN}}==
Defines a tacit Avg function which works on any simple numeric list.
<syntaxhighlight lang="bqn">Avg ← +´÷≠
Avg 1‿2‿3‿4</syntaxhighlight>
<syntaxhighlight lang="text">2.5</syntaxhighlight>
[https://mlochbaum.github.io/BQN/try.html#code=QXZnIOKGkCArwrTDt+KJoAoKQXZnIDHigL8y4oC/M+KAvzQ= Try It!]
=={{header|C}}==
Compute mean of a <code>double</code> array of given length. If length is zero, does whatever <code>0.0/0</code> does (usually means returning <code>NaN</code>).
<
double mean(double *v, int len)
Line 357 ⟶ 654:
return 0;
}</
mean[1, 2, 2.718, 3, 3.142] = 2.372
mean[1, 2, 2.718, 3] = 2.1795
Line 366 ⟶ 663:
</pre>
=={{header|C sharp|C#}}==
<
using System.Linq;
Line 376 ⟶ 673:
Console.WriteLine(new[] { 1, 2, 3 }.Average());
}
}</
Alternative version (not using the built-in function):
<
class Program
Line 407 ⟶ 704:
return d / nums.Length;
}
}</
=={{header|C++}}==
{{libheader|STL}}
<
double mean(const std::vector<double>& numbers)
Line 422 ⟶ 719:
sum += *i;
return sum / numbers.size();
}</
Shorter (and more idiomatic) version:
<
#include <algorithm>
Line 434 ⟶ 731:
return 0;
return std::accumulate(numbers.begin(), numbers.end(), 0.0) / numbers.size();
}</
Idiomatic version templated on any kind of iterator:
<
#include <algorithm>
Line 447 ⟶ 744:
return 0;
return std::accumulate(begin, end, 0.0) / std::distance(begin, end);
}</
=={{header|Chef}}==
<
Chef has no way to detect EOF, so rather than interpreting
Line 481 ⟶ 778:
Pour contents of mixing bowl into baking dish.
Serves 1.</
=={{header|Clojure}}==
Returns a [http://clojure.org/data_structures ratio]:
<
(if (empty? sq)
0
(/ (reduce + sq) (count sq))))</
Returns a float:
<
(if (empty? sq)
0
(float (/ (reduce + sq) (count sq)))))</
=={{header|COBOL}}==
Intrinsic function:
<
Sample implementation:
<
PROGRAM-ID. find-mean.
Line 529 ⟶ 826:
GOBACK
.</
=={{header|Cobra}}==
<
class Rosetta
def mean(ns as List<of number>) as number
Line 547 ⟶ 844:
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])]"
</syntaxhighlight>
Output:
Line 556 ⟶ 853:
=={{header|CoffeeScript}}==
<
mean = (array) ->
return 0 if array.length is 0
Line 564 ⟶ 861:
alert mean [1]
</syntaxhighlight>
=={{header|Common Lisp}}==
'''With Reduce'''
<
(
(/ (reduce #'+ sequence) (length sequence))))</syntaxhighlight>
'''With Loop'''
<
(
(/ (loop for i in list sum i)
(length list))))</
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">dim a[3, 1, 4, 1, 5, 9]
arraysize s, a
for i = 0 to s - 1
let t = t + a[i]
next i
print t / s</syntaxhighlight>
{{out| Output}}<pre>3.83</pre>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby"># Crystal will return NaN if an empty array is passed
def mean(arr) : Float64
arr.sum / arr.size.to_f
end</syntaxhighlight>
=={{header|D}}==
===Imperative Version===
<syntaxhighlight lang="d">real mean(Range)(Range r) pure nothrow @nogc {
real sum = 0.0;
int count;
Line 600 ⟶ 914:
void main() {
import std.stdio;
int[] data;
writeln("
data = [3, 1, 4, 1, 5, 9];
writeln("
}</
{{out}}
<pre>mean: 0
mean: 3.83333</pre>
===More Functional Version===
<
real mean(Range)(Range r) pure nothrow @nogc {
return r.sum / max(1.0L, r.count);
}
Line 618 ⟶ 934:
writeln("Mean: ", (int[]).init.mean);
writeln("Mean: ", [3, 1, 4, 1, 5, 9].mean);
}</
{{out}}
<pre>Mean: 0
Line 624 ⟶ 940:
===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):
<
CommonType!(T, real) mean(T)(T[] n ...) if (isNumeric!
alias E = CommonType!(T, real)
auto num = n.dup;
num.schwartzSort!(abs, "a > b"
return
}
Line 638 ⟶ 954:
writefln("%8.5f", mean( 0, 3, 1, 4, 1, 5, 9, 0));
writefln("%8.5f", mean([-1e20, 3, 1, 4, 1, 5, 9, 1e20]));
}</
{{out}}
<pre> 0.00000
Line 645 ⟶ 961:
=={{header|Dart}}==
<
void main(){
print(mean([1,2,3,4,5,6,7]));
}</
{{out}}
<pre>4.0</pre>
=={{header|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.
<syntaxhighlight lang="dc">1 2 3 5 7 zsn1k[+z1<+]ds+xln/p
3.6</syntaxhighlight>
An expanded example, identifying an empty sample set, could be created as a file, e.g., amean.cd:
<syntaxhighlight lang="dc">[[Nada Mean: ]Ppq]sq
zd0=qsn [stack length = n]sz
1k [precision can be altered]sz
[+z1<+]ds+x[Sum: ]Pp
ln/[Mean: ]Pp
[Sample size: ]Plnp</syntaxhighlight>
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:
<syntaxhighlight lang="dc">$ dc sample.dc amean.cd
Sum: 18
Mean: 3.6
Sample size: 5
$</syntaxhighlight>
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 674 ⟶ 1,014:
Writeln(Mean(TDoubleDynArray.Create()));
Writeln(Mean(TDoubleDynArray.Create(1,2,3,4,5)));
end.</
=={{header|Dyalect}}==
<syntaxhighlight lang="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)</syntaxhighlight>
=={{header|E}}==
Line 680 ⟶ 1,034:
Slightly generalized to support any object that allows iteration.
<
var count := 0
var sum := 0
Line 688 ⟶ 1,042:
}
return sum / 1.max(count)
}</
=={{header|
<syntaxhighlight lang="text">
proc mean . f[] r .
for i = 1 to len f[]
s += f[i]
.
r = s / len f[]
.
f[] = [ 1 2 3 4 5 6 7 8 ]
mean f[] r
print r
</syntaxhighlight>
=={{header|EchoLisp}}==
'''(mean values)''' is included in math.lib. values may be a list, vector, sequence, or any kind of procrastinator.
<syntaxhighlight lang="scheme">
(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
;; error handling
(mean 'elvis)
⛔ error: mean :
(mean ())
💣 error: mean :
(mean #())
😐 warning: mean : zero-divide : empty-vector
→ 0
(mean [2 2 .. 2])
😁 warning: mean : zero-divide : empty-sequence
→ 0
</syntaxhighlight>
=={{header|ECL}}==
<syntaxhighlight lang="ecl">
AveVal(SET OF INTEGER s) := AVE(s);
//example usage
SetVals := [14,9,16,20,91];
AveVal(SetVals) //returns 30.0 ;
</syntaxhighlight>
=={{header|EDSAC order code}}==
Extends the RC task by finding the arithmetic mean for each of several data sets. Each data set is preceded by the number of data. A count of 0 is not an error but signals that there are no more data sets.
The program needs to avoid the possibility of arithmetic overflow, as pointed out in the F# solution. The moving average used there is not well-suited to EDSAC, on which division had to be done by calling a subroutine. After reading the number of data N, and leaving the trivial case N = 1 for separate treatment, the program first calculates 1/N, then multiplies each value by 1/N before adding it into the result.
<syntaxhighlight lang="edsac">
[Averages/Arithmetic mean - Rosetta Code]
[EDSAC program (Initial Orders 2) to find and print the average of
a sequence of 35-bit fractional values.
Values are read from tape, preceded by an integer count.]
[Library subroutine M3, runs at load time and is then overwritten.
Prints header; here, last character sets teleprinter to figures.]
PF GK IF AF RD LF UF OF E@ A6F G@ E8F EZ PF
*!!!!!COUNT!!!!!!AVERAGE@&#.. [PZ]
[Main routine: must be at even address]
T214K GK
[0] PF PF [average value]
[2] PF PF [reciprocal of data count]
[4] PF [data count]
[5] PD [17-bit constant 1; also serves as '0' for printing]
[6] @F [carriage return]
[7] &F [line feed]
[8] !F [space]
[9] MF [dot (in figures mode)]
[10] K4096F [teleprinter null]
[Entry and outer loop]
[11] A11@
G56F [call library subroutine R4, sets 0D := data count N]
SD E64@ [exit if N = 0]
T4F [clear acc]
AF T4@ [load and save N (assumed < 2^16)]
[18] A18@ G156F [print N (clears acc)]
TD [clear whole of 0D, including sandwich bit]
T4D [same for 4D]
A4@ S2F [acc := N - 2]
G66@ [jump to special action if N = 1]
A2F [restore N after test]
T5F [store N in 4D high word]
A5@ T1F [store 1 in 0D high word]
[29] A29@ G120F [call library subroutine D6, sets 0D := 0D/4D]
AD T2#@ [load and save 1/N]
T#@ [clear average]
S4@ [load -N]
[Inner loop]
[35] T4@ [update negative loop counter]
[36] A36@ G78F [read next datum to 0D (clears acc)]
H2#@ [mult reg := 1/N]
VD [acc := datum/N]
A#@ T#@ [add into average]
A4@ A5@ [increment negative loop counter]
G35@ [loop until counter = 0]
[45] O8@ O8@ [print 2 spaces]
[Print the average value.
NB: Library subroutine P1 requires non-negative input and prints only the
digits after the decimal point. Formatting has to be done by the caller.]
[47] A#@ [load average (order also serves as minus sign)]
G52@ [jump if average < 0]
TD [pass average to subroutine P1]
O65@ [print plus sign (or could be space)]
E56@ [join common code]
[52] TD [average < 0; clear acc]
S#@ TD [pass abs(average) to subroutine P1]
O47@ [print minus sign]
[56] O5@ O9@ [common code: print '0.']
[58] A58@ G192F [call P1 to print abs(average)]
P8F [8 decimal places]
O6@ O7@ [print CR, LF]
E11@ [loop back always (because acc = 0)]
[Jump to here if data count = 0, means end of data]
[64] O10@ [print null to flush teleprinter buffer]
[65] ZF [halt the machine (order also serves as plus sign)]
[Jump to here if data count = 1]
[66] TF [clear acc]
[67] A67@ G78F [read datum to 0D]
AD T#@ [average := datum]
E45@ [jump to print the average]
[The following puts the entry address into location 50,
so that it can be accessed via the X parameter (see end of program).
This is done in case the data is input from a separate tape.]
T50K P11@ T11Z
[Library subroutine R4.
Input of one signed integer, returned in 0D.]
T56K
GKA3FT21@T4DH6@E11@P5DJFT6FVDL4FA4DTDI4FA4FS5@G7@S5@G20@SDTDT6FEF
[Library subroutine R3.
Input of one long signed decimal fraction, returned in 0D.]
T78K
GKT45KP26@TZA3FTHTDT4DA6HT9@H1HS4HT6FIFAFS4HE7HT7FV4DL8FADT4DA6FA5HG8@
H2#HN4DLDYFTDT28#ZPFT27ZTFP610D@524DP5DPDIFS4HG37@S4DT4DT7FA1HT9@E18@
[Library subroutine D6 - Division, accurate, fast.
36 locations, workspace 6D and 8D.
0D := 0D/4D, where 4D <> 0, -1.]
T120K
GKA3FT34@S4DE13@T4DSDTDE2@T4DADLDTDA4DLDE8@RDU4DLDA35@
T6DE25@U8DN8DA6DT6DH6DS6DN4DA4DYFG21@SDVDTDEFW1526D
[Library subroutine P7: print strictly positive integer in 0D.]
T156K
GKA3FT26@H28#@NDYFLDT4DS27@TFH8@S8@T1FV4DAFG31@SFLDUFOFFFSF
L4FT4DA1FA27@G11@T28#ZPFT27ZP1024FP610D@524D!FO30@SFL8FE22@
[Library subroutine P1: print non-negative fraction in 0D, without '0.']
T192K
GKA18@U17@S20@T5@H19@PFT5@VDUFOFFFSFL4FTDA5@A2FG6@EFU3FJFM1F
[==========================================================================
On the original EDSAC, the following (without the whitespace and comments)
might have been input on a separate tape.]
E25K TX GK
EZ [define entry point]
PF [acc = 0 on entry]
[Counts and data values to be read by library subroutines R3 and R4 respectively.
Note (1) Sign comes *after* value (2) In the data, leading '0.' is omitted.]
7+ 1-2-3-4-5+2-3-
1+ 987654321+
9+ 01+04+09+16+25+36+49+64+81+
9+ 01-04+09-16+25-36+49-64+81-
[Daily minimum temperature (unit = 10 deg. C), Cambridge, UK, January 2000]
31+ 34+14+49+00+04+48+05+48+23-35-07-75+19+03+
26+27+17-06-52+22-17+18+15+03-33-11-04-01-44+89+95+
0+
</syntaxhighlight>
{{out}}
<pre>
COUNT AVERAGE
7 -0.14285714
1 +0.98765432
9 +0.31666666
9 -0.05000000
31 +0.16774193
</pre>
=={{header|Elena}}==
ELENA 6.x:
<syntaxhighlight lang="elena">import extensions;
extension op
{
average()
{
real sum := 0;
int count := 0;
var enumerator := self.enumerator();
while (enumerator.next())
{
sum += *enumerator;
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()
}</syntaxhighlight>
{{out}}
<pre>
Arithmetic mean of {1,2,3,4,5,6,7,8} is 4.5
</pre>
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">defmodule Average do
def mean(list), do: Enum.sum(list) / length(list)
end</syntaxhighlight>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang
{{libheader|Calc}}
<syntaxhighlight lang="lisp">(let ((x '(1 2 3 4)))
(calc-eval "vmean($1)" nil (append '(vec) x)))</syntaxhighlight>
=={{header|EMal}}==
<syntaxhighlight lang="emal">
fun mean = real by some real values
real sum
int count
for each real value in values
sum += value
++count
end
return when(count == 0, 0.0, sum / count)
end
writeLine(mean())
writeLine(mean(3,1,4,1,5,9))
</syntaxhighlight>
{{out}}
<pre>
0.0
3.8333333333333333333333333333
</pre>
=={{header|Erlang}}==
<
mean(L) -> lists:sum(L)/erlang:length(L).</
=={{header|Euphoria}}==
<
atom sum
if length(s) = 0 then
Line 749 ⟶ 1,323:
sequence test
test = {1.0, 2.0, 5.0, -5.0, 9.5, 3.14159}
? mean(test)</
=={{header|Excel}}==
Assuming the values are entered in the A column, type into any cell which will not be part of the list:
<
Assuming 10 values will be entered, alternatively, you can just type:
<
and then select the start and end cells, not necessarily in the same row or column.
Line 776 ⟶ 1,350:
10
</pre>
=={{header|F_Sharp|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 [[wp:Moving_average|wikipedia]] about the moving average computation.
<syntaxhighlight lang="fsharp">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</syntaxhighlight>
Checking this:
<syntaxhighlight lang="fsharp"> > 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</syntaxhighlight>
We can also make do with the built-in ''List.average'' function:
<syntaxhighlight lang="fsharp">List.average [4;1;7;5;8;4;5;2;1;5;2;5]</syntaxhighlight>
=={{header|Factor}}==
<
: arithmetic-mean ( seq -- n )
[ 0 ] [ mean ] if-empty ;</
Tests:
<
3.333333333333333</
=={{header|Fantom}}==
<
class Main
{
Line 809 ⟶ 1,401:
}
}
</syntaxhighlight>
=={{header|Fish}}==
<
v< +<>0n; >n;
>l1)?^&,n;</
Must be called with the values pre-populated on the stack, which can be done in the <tt>fish.py</tt> interpreter with the <tt>-v</tt> switch:
<pre>fish.py mean.fish -v 10 100 47 207.4</pre>
Line 821 ⟶ 1,413:
=={{header|Forth}}==
<
0e
dup 0= if 2drop exit then
Line 830 ⟶ 1,422:
create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,
test 6 fmean f. \ 3.83333333333333</
=={{header|Fortran}}==
In ISO Fortran 90 or later, use the SUM intrinsic, the SIZE intrinsic and the MAX intrinsic (to avoid divide by zero):
<
real, dimension(5,20) :: b = reshape( a, (/ 5,20 /) )
real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array
Line 853 ⟶ 1,445:
! 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)</
=={{header|FreeBASIC}}==
<syntaxhighlight lang="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/length
End Function
Function IsNaN(number As Double) As Boolean
Return Str(number) = "-1.#IND" ' NaN as a string in FB
End Function
Dim As Integer n, i
Dim As Double num
Print "Sample input and output"
Print
Do
Input "How many numbers are to be input ? : ", n
Loop Until n > 0
Dim vector(1 To N) As Double
Print
For i = 1 to n
Print " Number #"; i; " : ";
Input "", vector(i)
Next
Print
Print "Mean is"; Mean(vector())
Print
Erase vector
num = Mean(vector())
If IsNaN(num) Then
Print "After clearing the vector, the mean is 'NaN'"
End If
Print
Print "Press any key to quit the program"
Sleep
</syntaxhighlight>
{{out}}
<pre>
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'
</pre>
=={{header|Frink}}==
The following works on arrays or sets. If the collection is empty, this returns the special value <CODE>undef</CODE>.
<
mean[x] := length[x] > 0 ? sum[x] / length[x] : undef
</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn MeanAverageOfNumberArray( numberArr as CFArrayRef ) as CFStringRef
CFStringRef result = NULL
if len(numberArr) == 0 then result = @"Mean undefined for empty array." : exit fn
result = fn StringWithFormat( @"Mean average of %d numbers: %@", len(numberArr), fn ObjectValueForKeyPath( numberArr, @"@avg.self" ) )
end fn = result
CFArrayRef numberArray
numberArray = @[@1, @2, @3, @4, @5, @6, @7, @8, @9, @10]
print fn MeanAverageOfNumberArray( numberArray )
numberArray = @[@3, @1, @4, @1, @5, @9]
print fn MeanAverageOfNumberArray( numberArray )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
Mean average of 10 numbers: 5.5
Man average of 6 numbers: 3.83333333333333333333333333333333333333
</pre>
</pre>
=={{header|GAP}}==
<
local n;
n := Length(v);
Line 891 ⟶ 1,556:
Mean([3, 1, 4, 1, 5, 9]);
# 23/6</
=={{header|GEORGE}}==
<syntaxhighlight lang="george">R (n) P ;
0
1, n rep (i)
R P +
]
n div
P</syntaxhighlight>
Output:
<pre>
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
</pre>
=={{header|GFA Basic}}==
This works for arrays of integers.
<syntaxhighlight lang="text">
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
</syntaxhighlight>
=={{header|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.
<
import (
Line 971 ⟶ 1,678:
}
}
}</
{{out}}
<pre>
Line 997 ⟶ 1,704:
=={{header|Groovy}}==
<
Test Program:
<
println avg([2,2,2,4,2])
println avg ([])</
Output:
Line 1,011 ⟶ 1,718:
=={{header|Haskell}}==
This function works if the element type is an instance of Fractional:
<
mean [] = 0
mean xs = sum xs / Data.List.genericLength xs</
But some types, e.g. integers, are not Fractional; the following function works for all Real types:
<
meanReals = mean . map realToFrac</
If you want to avoid keeping the list in memory and traversing it twice:
<
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)
main :: IO ()
main = print $ mean [1 .. 100]</syntaxhighlight>
=={{header|HicEst}}==
<
vec = $ - 1/2 ! 0.5 ... 99.5
mean = SUM(vec) / LEN(vec) ! 50
END </
=={{header|Hy}}==
Returns <tt>None</tt> if the input is of length zero.
<syntaxhighlight lang="clojure">(defn arithmetic-mean [xs]
(if xs
(/ (sum xs) (len xs))))</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
<
every (s := 0) +:= !args
write((real(s)/(0 ~= *args)) | 0)
end</
Sample outputs:
Line 1,051 ⟶ 1,778:
If truly only the mean is wanted, one could use
<
print,mean(x)</
But <tt>mean()</tt> is just a thin wrapper returning the zeroth element of <tt>moment()</tt> :
<
; ==>
3.83333 8.96667 0.580037 -1.25081</
which are mean, variance, skewness and kurtosis.
Line 1,066 ⟶ 1,793:
=={{header|J}}==
<
That is, sum divided by the number of items. The verb also works on higher-ranked arrays. For example:
<
3.83333
mean $0 NB. $0 is a zero-length vector
Line 1,076 ⟶ 1,803:
x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers
mean x
0.58243 0.402948 0.477066 0.511155</
The computation can also be written as a loop. It is shown here for comparison only and is highly non-preferred compared to the version above.
<
z=. 0
for_i. i.#y do. z=. z+i{y end.
Line 1,090 ⟶ 1,817:
0
mean1 x
0.58243 0.402948 0.477066 0.511155</
=={{header|Java}}==
{{works with|Java|1.5+}}
<syntaxhighlight lang="java5">public static double avg(double... arr) {
double sum = 0.0;
for (double
sum += x;
return sum / arr.length;
}</syntaxhighlight>
=={{header|JavaScript}}==
===ES5===
<syntaxhighlight lang="javascript">function mean(array)
{
var sum = 0, i;
Line 1,115 ⟶ 1,844:
}
alert( mean( [1,2,3,4,5] ) ); // 3
alert( mean( [] ) ); // 0</syntaxhighlight>
Using the native function `.forEach()`:
<syntaxhighlight lang="javascript">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</syntaxhighlight>
Using the native function `.reduce()`:
<syntaxhighlight lang="javascript">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] ) ); // 3
alert( mean( [] ) ); // 0
</syntaxhighlight>
Extending the `Array` prototype:
<syntaxhighlight lang="javascript">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() ); // 3
alert( [].mean() ); // 0
</syntaxhighlight>
{{libheader|Functional}}
<
{
return a.length ? Functional.reduce('+', 0, a) / a.length : 0;
}</
===ES6===
<syntaxhighlight lang="javascript">(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]);</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="javascript">5</syntaxhighlight>
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE avg == dup 0. [+] fold swap size 1 max /.</syntaxhighlight>
=={{header|jq}}==
The mean of an array of numbers can be computed by simply writing
<syntaxhighlight lang="jq">add/length</syntaxhighlight>
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:
<syntaxhighlight lang="jq">def mean: if length == 0 then null
else add/length
end;</syntaxhighlight>
=={{header|Julia}}==
Julia's built-in mean function accepts AbstractArrays (vector, matrix, etc.)
<
2.0
julia> mean(1:10)
5.5
julia> mean([])
ERROR: mean of empty collection undefined: []</
=={{header|K}}==
<
mean 1 2 3 5 7
3.6
mean@!0 / empty array
0.0</
=={{header|Kotlin}}==
Kotlin has builtin functions for some collection types.
Example:
<syntaxhighlight lang="scala">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()))
}</syntaxhighlight>
=={{header|KQL}}==
<syntaxhighlight lang="kql">
let dataset = datatable(values:real)[
1, 1.5, 3, 5, 6.5];
dataset|summarize avg(values)
</syntaxhighlight>
Output:
<pre>
avg_values
3.4
</pre>
=={{header|LabVIEW}}==
{{VI solution|LabVIEW_Averages_Arithmetic_mean.png}}
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def mean
{lambda {:s}
{if {S.empty? :s}
then 0
else {/ {+ :s} {S.length :s}}}}}
{mean {S.serie 0 1000}}
-> 500
</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="langur">val .mean = fn .x: fold(fn{+}, .x) / len(.x)
writeln " custom: ", .mean([7, 3, 12])
writeln "built-in: ", mean([7, 3, 12])</syntaxhighlight>
{{out}}
<pre> custom: 7.333333333333333333333333333333333
built-in: 7.333333333333333333333333333333333</pre>
=={{header|Lasso}}==
<
not #a->size ? return 0
local(x = 0.0)
Line 1,150 ⟶ 1,998:
}
average(array(1,2,5,17,7.4)) //6.48</
=={{header|
=== 1-Arity ===
<syntaxhighlight lang="lisp">
(defun mean (data)
(/ (lists:sum data)
(length data)))
</syntaxhighlight>
Usage:
<syntaxhighlight lang="lisp">> (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</syntaxhighlight>
=== n-Arity ===
Functions in LFE (and Erlang) have set arity, but macros can be used to provide the same use as n-arity functions:
<syntaxhighlight lang="lisp">(defmacro mean args
`(/ (lists:sum ,args)
,(length args)))</syntaxhighlight>
Usage:
<syntaxhighlight lang="lisp">> (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</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
dim nums(total)
for i = 1 to total
Line 1,171 ⟶ 2,049:
if total=0 then mean=0 else mean=sum/total
print "Arithmetic mean: ";mean
</
=={{header|Limbo}}==
<syntaxhighlight lang="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);
}</syntaxhighlight>
=={{header|Lingo}}==
<syntaxhighlight lang="lingo">-- v can be (2D) point, (3D) vector or list of integers/floats
on 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)/cnt
end</syntaxhighlight>
<syntaxhighlight lang="lingo">put mean(point(1, 2.5))
-- 1.7500
put mean(vector(1.2, 4.7, 5.6))
-- 3.8333
put mean([6,12,18,24,30,36,42,48,54,60,66,72,78])
-- 42.0000</syntaxhighlight>
=={{header|LiveCode}}==
Livecode provides arithmeticMean (avg, average) built-in.
<syntaxhighlight lang="livecode">average(1,2,3,4,5) -- 3
average(empty) -- 0</syntaxhighlight>
=={{header|Logo}}==
<syntaxhighlight 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</syntaxhighlight>
=={{header|Logtalk}}==
Logtalk's standard library provides an arithmetic average predicate but we ignore it here. Representing a vector using a list:
<
:- object(averages).
Line 1,193 ⟶ 2,132:
:- end_object.
</syntaxhighlight>
Sample output:
<
| ?- averages::arithmetic([1,2,3,4,5,6,7,8,9,10], Mean).
Mean = 5.5
yes
</syntaxhighlight>
=={{header|LSL}}==
<
integer MAX_VALUE = 100;
default {
Line 1,223 ⟶ 2,162:
llOwnerSay(" Sum Squares: "+(string)llListStatistics(LIST_STAT_SUM_SQUARES, lst));
}
}</
Output:
<pre>
Line 1,240 ⟶ 2,179:
=={{header|Lua}}==
<
if type(numlist) ~= 'table' then return numlist end
num = 0
Line 1,247 ⟶ 2,186:
end
print (mean({3,1,4,1,5,9}))</
=={{header|Lucid}}==
<
where
sum = first(x) fby sum + next(x);
n = 1 fby n + 1;
avg = sum / n;
end</
=={{header|M4}}==
Line 1,264 ⟶ 2,203:
directly, but it is a little bit clearer to keep them separated.
<
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</
<
=={{header|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.
<syntaxhighlight lang="maple">
mean := proc( a :: indexable )
local i;
Normalizer( add( i, i in a ) / numelems( a ) )
end proc:
</syntaxhighlight>
For example:
<syntaxhighlight lang="maple">
> mean( { 1/2, 2/3, 3/4, 4/5, 5/6 } ); # set
71
Line 1,302 ⟶ 2,241:
> mean([]); # empty argument causes an exception to be raised.
Error, (in mean) numeric exception: division by zero
</syntaxhighlight>
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.
<
This can be called as in the following examples.
<syntaxhighlight lang="maple">
> mean( 1, 2, 3, 4, 5 );
3
Line 1,317 ⟶ 2,256:
> mean(); # again, an exception is raised
Error, (in mean) numeric exception: division by zero
</syntaxhighlight>
If desired, we can add argument type-checking as follows.
<
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Modify the built-in Mean function to give 0 for empty vectors (lists in Mathematica):
<
Mean[{}] := 0</
Examples:
<
Mean[{3.2,4.5,5.9}]
Mean[{-4, 1.233}]
Mean[{}]
Mean[{1/2,1/3,1/4,1/5}]
Mean[{a,c,Pi,-3,a}]</
gives (a set of integers gives back an integer or a rational, a set of floats gives back a float, a set of rationals gives a rational back, a list of symbols and numbers keeps the symbols exact and a mix of exact and approximate numbers gives back an approximate number):
<
4.53333
-1.3835
0
77/240
1/5 (-3+2 a+c+Pi)</
=={{header|Mathprog}}==
Line 1,350 ⟶ 2,289:
To make it more interesting I find the Arithmectic Mean of more than a million Integers.
<syntaxhighlight lang="text">
/*Arithmetic Mean of a large number of Integers
- or - solve a very large constraint matrix
Line 1,375 ⟶ 2,314:
end;
</syntaxhighlight>
When run this produces:
<syntaxhighlight lang="text">
GLPSOL: GLPK LP/MIP Solver, v4.47
Parameter(s) specified in the command line:
Line 1,402 ⟶ 2,341:
The arithmetic mean of the integers from 1 to 1048575 is 524288.000000
Model has been successfully processed
</syntaxhighlight>
=={{header|MATLAB}}==
<
meanValue = mean(setOfValues);
end</
=={{header|Maxima}}==
<
mean([2, 7, 11, 17]);</
=={{header|MAXScript}}==
<
(
total = 0
Line 1,424 ⟶ 2,363:
)
print (mean #(3, 1, 4, 1, 5, 9))</
=={{header|Mercury}}==
<syntaxhighlight lang="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.</syntaxhighlight>
Alternatively, we could use inst subtyping to ensure we get a compilation error if the
mean function is called with an empty list.
<syntaxhighlight lang="mercury">:- func mean(list(float)::in(non_empty_list)) = (float::out).
mean(Ns) = foldl((+), Ns, 0.0) / float(length(Ns)).</syntaxhighlight>
=={{header|min}}==
Returns <code>nan</code> for an empty quotation.
{{works with|min|0.37.0}}
<syntaxhighlight lang="min">(2 3 5) avg puts!</syntaxhighlight>
{{out}}
<pre>3.333333333333333</pre>
=={{header|MiniScript}}==
<syntaxhighlight lang="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.len
end function
print avg(arr)</syntaxhighlight>
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">0 П0 П1 С/П ИП0 ИП1 * + ИП1 1
+ П1 / П0 БП 03</
''Instruction:'' В/О С/П Number С/П Number ...
Line 1,435 ⟶ 2,424:
=={{header|Modula-2}}==
<
VAR avg : REAL;
Line 1,444 ⟶ 2,433:
InOut.WriteReal (avg, 8, 2);
InOut.WriteLn
END Avg;</
OR
<
(* Calculate the average over 'Samples' values, stored in array 'Data'. *)
Line 1,459 ⟶ 2,448:
END;
RETURN sum / FLOAT(Samples)
END Average;</
=={{header|MUMPS}}==
<
;X is assumed to be a list of numbers separated by "^"
QUIT:'$DATA(X) "No data"
Line 1,468 ⟶ 2,458:
SET S=0,I=1
FOR QUIT:I>$L(X,"^") SET S=S+$P(X,"^",I),I=I+1
QUIT (S/$L(X,"^"))</
<pre>USER>W $$MEAN^ROSETTA
No data
Line 1,478 ⟶ 2,468:
5.75
</pre>
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">def sum(lst)
sum = 0
for n in lst
sum += n
end
return sum
end
def average(x)
return sum(x) / len(x)
end</syntaxhighlight>
=={{header|Nemerle}}==
<
using System.Console;
using Nemerle.Collections;
Line 1,496 ⟶ 2,499:
WriteLine("Mean of [1 .. 10]: {0}", ArithmeticMean($[1 .. 10]));
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,550 ⟶ 2,553:
]
return vectors
</syntaxhighlight>
'''Output:'''
<pre>
Line 1,574 ⟶ 2,577:
=={{header|NewLISP}}==
<
(if (empty? Lst)
0
Line 1,580 ⟶ 2,583:
(Mean (sequence 1 1000))-> 500
(Mean '()) -> 0</
=={{header|Nial}}==
in the standard way, mean is
<
mean 6 2 4
= 4</
but it fails with 0 length vectors. so using a tally with a minimum value 1
<
mean is / [sum, dtally]
mean []
=0</
=={{header|Nim}}==
{{trans|C}}
<syntaxhighlight lang="nim">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)</syntaxhighlight>
Output:
<pre>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</pre>
=={{header|Niue}}==
<syntaxhighlight 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 ;
Line 1,605 ⟶ 2,629:
3.4 2.3 .01 2.0 2.1 avg .
=> 1.9619999999999997
</syntaxhighlight>
=={{header|Oberon-2}}==
Oxford Oberon-2
<
MODULE AvgMean;
IMPORT Out;
Line 1,638 ⟶ 2,663:
Out.Fixed(Avg(ary),4,2);Out.Ln
END AvgMean.
</syntaxhighlight>
Output:
<pre>
14.55
</pre>
=={{header|Objeck}}==
<
function : native : PrintAverage(values : FloatVector) ~ Nil {
values->Average()->PrintLine();
}
</syntaxhighlight>
=={{header|OCaml}}==
These functions return a float:
<
| [] -> 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
Line 1,669 ⟶ 2,695:
would rather be handled by an exception.
<
if xs = [] then
invalid_arg "empty list"
Line 1,692 ⟶ 2,718:
in
(float total /. length)
;;</
=={{header|Octave}}==
Line 1,698 ⟶ 2,724:
GNU Octave has a <tt>mean</tt> function (from statistics package), but it does not handle an empty vector; an implementation that allows that is:
<
if ( numel(l) == 0 )
m = 0;
Line 1,707 ⟶ 2,733:
disp(omean([]));
disp(omean([1,2,3]));</
If the data contains missing value, encoded as non-a-number:
<
n = sum(~isnan(l));
l(isnan(l))=0;
s = sum(l);
m = s./n;
end;</
=={{header|Oforth}}==
<syntaxhighlight lang="oforth">: avg ( x -- avg )
x sum
x size dup ifZero: [ 2drop null ] else: [ >float / ]
;</syntaxhighlight>
{{out}}
<pre>
[1, 2, 2.718, 3, 3.142] avg .
2.372 ok
[ ] avg .
null ok
</pre>
=={{header|ooRexx}}==
<syntaxhighlight lang="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)
Line 1,741 ⟶ 2,782:
end
return sum/numbers~items
</syntaxhighlight>
Output:
<pre>
Line 1,759 ⟶ 2,800:
=={{header|Oz}}==
A version working on floats:
<
fun {Mean Xs}
{FoldL Xs Number.'+' 0.0} / {Int.toFloat {Length Xs}}
end
in
{Show {Mean [3. 1. 4. 1. 5. 9.]}}</
=={{header|PARI/GP}}==
<
if(#v,vecsum(v)/#v)
};</
=={{header|Pascal}}==
<
function DoMean(vector: array of double): double;
Line 1,801 ⟶ 2,842:
writeln (']');
writeln('Mean: ', DoMean(vector):10:8);
end.</
Output:
Line 1,812 ⟶ 2,853:
Alternative version using the Math unit:
<
uses math;
const
Line 1,829 ⟶ 2,870:
mean := sum(vector)/length(vector);
writeln('Mean: ', mean:10:8);
end.</
=={{header|Perl}}==
<
@_ or return 0;
my $sum = 0;
Line 1,839 ⟶ 2,880:
}
print avg(qw(3 1 4 1 5 9)), "\n";</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)/</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">9.5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3.14159</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
=={{header|
<syntaxhighlight lang="phixmonti">1 2 5 -5 -9.5 3.14159 stklen tolist
len swap sum swap / print</syntaxhighlight>
=={{header|PHP}}==
<
if ($nums)
echo array_sum($nums) / count($nums), "\n";
else
echo "0\n";</
=={{header|Picat}}==
<syntaxhighlight lang="picat">mean([]) = false.
mean(V) = sum(V) / len(V).</syntaxhighlight>
=={{header|PicoLisp}}==
<
(if (atom Lst)
0
(/ (apply + Lst) (length Lst)) ) )</
Output:
<pre>: (mean (range 1 1000))
-> 500</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pli">arithmetic_mean = sum(A)/dimension(A,1);</syntaxhighlight>
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">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.</syntaxhighlight>
{{out}}
<pre>
A list: 1, 2, 5-1/3, 7-1/2
The list's mean: 3-23/24
</pre>
=={{header|Pop11}}==
<
lvars n = length(v), i, s = 0;
if n = 0 then
Line 1,885 ⟶ 2,990:
endif;
return(s/n);
enddefine;</
=={{header|PostScript}}==
<syntaxhighlight lang="text">
/findmean{
/x exch def
Line 1,904 ⟶ 3,009:
sum ==
}def
</syntaxhighlight>
{{libheader|initlib}}
{{works with|Ghostscript}}
<
/avg {
dup length
Line 1,917 ⟶ 3,022:
} ifte
}.
</syntaxhighlight>
=={{header|PowerShell}}==
The hard way by calculating a sum and dividing:
<
if ($x.Count -eq 0) {
return 0
Line 1,931 ⟶ 3,036:
return $sum / $x.Count
}
}</
or, shorter, by using the <code>Measure-Object</code> cmdlet which already knows how to compute an average:
<
if ($x.Count -eq 0) {
return 0
Line 1,939 ⟶ 3,044:
return ($x | Measure-Object -Average).Average
}
}</
=={{header|Processing}}==
<syntaxhighlight lang="processing">float mean(float[] arr) {
float out = 0;
for (float n : arr) {
out += n;
}
return out / arr.length;
}</syntaxhighlight>
=={{header|Prolog}}==
{{works with|SWI-Prolog|6.6}}
<syntaxhighlight lang="prolog">
mean(List, Mean) :-
length(List, Length),
sumlist(List, Sum),
Mean is Sum / Length.
</syntaxhighlight>
=={{header|PureBasic}}==
<
Protected sum=0
Line 1,950 ⟶ 3,075:
ProcedureReturn sum / ListSize(number())
; Depends on programm if zero check needed, returns nan on division by zero
EndProcedure</
=={{header|Python}}==
{{works with|Python|3.0}}.<br>{{works with|Python|2.6}}<br>
Uses [http://docs.python.org/3.3/library/math.html?highlight=fsum#math.fsum fsum] which tracks multiple partial sums to avoid losing precision
<
def average(x):
return fsum(x)/float(len(x)) if x else 0
print (average([0,0,3,1,4,1,5,9,0,0]))
print (average([1e20,-1e-20,3,1,4,1,5,9,-1e20,1e-20]))</
{{out}}
<
2.3</
{{works with|Python|2.5}}
<
return sum(x)/float(len(x)) if x else 0
print (average([0,0,3,1,4,1,5,9,0,0]))
print (average([1e20,-1e-20,3,1,4,1,5,9,-1e20,1e-20]))</
{{out}}
(Notice how the second call gave the wrong result)
<
1e-21</
{{works with|Python|2.4}}
<
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])</
{{out}}
<syntaxhighlight lang
{{works with|Python|3.4}}
Since 3.4, Python has a [[http://docs.python.org/3/library/statistics.html 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.)
<syntaxhighlight lang="python">>>> 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')</syntaxhighlight>
=={{header|Q}}==
A built-in solution is <tt>avg</tt>. An implementation of it could be:
<syntaxhighlight lang="q">mean:{(sum x)%count x}</syntaxhighlight>
=={{header|Quackery}}==
Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.
<syntaxhighlight lang="quackery"> [ $ '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 ( --> )</syntaxhighlight>
{{out}}
<pre>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, -5/12, -16621/39892</pre>
=={{header|R}}==
R has its <tt>mean</tt> 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:
<
m <- mean(v)
ifelse(is.na(m), 0, m)
}</
=={{header|Racket}}==
Line 2,001 ⟶ 3,224:
Racket's math library (available in v5.3.2 and newer) comes with a <tt>mean</tt> function that works on arbitrary sequences.
<
#lang racket
(require math)
Line 2,008 ⟶ 3,231:
(mean '(2 2 4 4)) ; -> 3
(mean #(3 4 5 8)) ; -> 5
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.10-11}}
<syntaxhighlight lang="raku" line>multi mean([]){ Failure.new('mean on empty list is not defined') }; # Failure-objects are lazy exceptions
multi mean (@a) { ([+] @a) / @a }</syntaxhighlight>
=={{header|Rapira}}==
<syntaxhighlight lang="rapira">fun mean(arr)
sum := 0
for N from 1 to #arr do
sum := sum + arr[N]
od
return (sum / #arr)
end</syntaxhighlight>
=={{header|REBOL}}==
<
Title: "Arithmetic Mean (Average)"
URL: http://rosettacode.org/wiki/Average/Arithmetic_mean
]
Line 2,031 ⟶ 3,268:
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:
Line 2,039 ⟶ 3,276:
[1000 3 1 4 1 5 9 -1000] -> 2.875
[1E+20 3 1 4 1 5 9 -1E+20] -> 0.0</pre>
=={{header|Red}}==
Red comes with the <code>average</code> function.
<syntaxhighlight lang="red">Red ["Arithmetic mean"]
print average []
print average [2 3 5]</syntaxhighlight>
{{out}}
<pre>
none
3.333333333333334
</pre>
The source code for <code>average</code>:
<syntaxhighlight lang="red">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
]</syntaxhighlight>
=={{header|ReScript}}==
<syntaxhighlight lang="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))</syntaxhighlight>
{{out}}
<pre>
$ bsc arithmean.res > arithmean.js
$ node arithmean.js
5.5
</pre>
=={{header|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.
<syntaxhighlight lang="rexx">/*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. */</syntaxhighlight>
'''output''' when using the (internal) lists:
<pre>
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.]
═══════════════════════════════════════════════════════════════════════════════
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
nums = [1,2,3,4,5,6,7,8,9,10]
sum = 0
see "Average = " + average(nums) + nl
func average numbers
for i = 1 to len(numbers)
sum = sum + nums[i]
next
return sum/len(numbers)
</syntaxhighlight>
=={{header|RPL}}==
This is based on the dc version above.
{{works with|HP|48G}}
≪ DUP 'N' STO →LIST ΣLIST N / 'N' PURGE ≫ '<span style="color:blue">AMEAN</span>' STO
or,by using the stack instead of a temporary variable:
≪ →LIST ΣLIST LASTARG SIZE / ≫ '<span style="color:blue">AMEAN</span>' STO
CLEAR 1 2 3 5 7 DEPTH <span style="color:blue">AMEAN</span>
===Hard-working approach===
Works for all RPL versions.
≪ DUP SIZE SWAP OVER
0 1 ROT '''FOR''' j
OVER j GET + '''NEXT'''
ROT / SWAP DROP
≫
===Hard-working approach with local variables===
No significant impact on program size or speed, but much more readable
≪ DUP SIZE → vector n
≪ 0 1 n '''FOR''' j
vector j GET + '''NEXT'''
n /
≫ ≫
===Straightforward approach===
The dot product of any vector with [1 1 ... 1] gives the sum of its elements.
≪ SIZE LAST DUP 1 CON DOT SWAP / ≫
''''AMEAN'''' STO
===Using built-in statistics features===
Most of the code is dedicated to store the input array according to built-in statistics requirements, which requires a matrix with one line per record. Main benefit of this approach is that you can then easily calculate standard deviation and variance by calling resp. <code>SDEV</code> and <code>VAR</code> functions.
≪ { 1 } OVER SIZE + RDM TRN '∑DAT' STO MEAN ≫ ''''AMEAN'''' STO
[ 1 5 0 -4 6 ] '''AMEAN'''
{{out}}
<pre>
1: 1.6
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang
end
nums = [3, 1, 4, 1, 5, 9]
nums.size.downto(0) do |i|
ary = nums[0,i]
puts "array size #{ary.size} : #{mean(ary)}"
end</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Run BASIC}}==
<
dim value(numArray)
for i = 1 to numArray
Line 2,108 ⟶ 3,461:
next
if totValue <> 0 then mean = totValue/numArray
print "The mean is: ";mean</
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn sum(arr: &[f64]) -> f64 {
arr.iter().fold(0.0, |p,&q| p + q)
}
fn mean(arr: &[f64]) -> 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:
<pre>mean of [2, 3, 5, 7, 13, 21, 33, 54]: 17.25
mean of []:
=={{header|Sather}}==
Built to work with VEC, ("geometric" vectors), whose elements must be floats. A 0-dimension vector yields "nan".
<
mean(v:VEC):FLT is
m ::= 0.0;
Line 2,146 ⟶ 3,498:
#OUT + VECOPS::mean(v) + "\n";
end;
end;</
=={{header|Scala}}==
Using Scala 2.7, this has to be defined for each numeric type:
<
However, Scala 2.8 gives much more flexibility, but you still have to opt
between integral types and fractional types. For example:
<
import n._
s.foldLeft(zero)(_+_) / fromInt(s.size)
}</
This can be used with any subclass of <tt>Sequence</tt> on integral types, up
Line 2,169 ⟶ 3,521:
Alas, Scala 2.8 also simplifies the task in another way:
<
Here we show a function that supports fractional types. Instead of importing the definitions
Line 2,177 ⟶ 3,529:
=={{header|Scheme}}==
<
(if (null? l)
0
(/ (apply + l) (length l))))</
> (mean (list 3 1 4 1 5 9))
Line 2,186 ⟶ 3,538:
=={{header|Seed7}}==
<
include "float.s7i";
Line 2,209 ⟶ 3,561:
begin
writeln(mean(numVector));
end func;</
=={{header|SenseTalk}}==
SenseTalk has a built-in average function.
<syntaxhighlight lang="sensetalk">put the average of [12,92,-17,66,128]
put average(empty)
</syntaxhighlight>
{{out}}
<pre>
56.2
nan
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func avg(Array list) {
list.len > 0 || return 0
list.sum / list.len
}
say avg([Inf, 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])</syntaxhighlight>
{{out}}
<pre>
Inf
3.83333333333333333333333333333333333333333333333
2.875
3.674
-130.6625
</pre>
=={{header|Slate}}==
<
[|:list| (list reduce: #+ `er ifEmpty: [0]) / (list isEmpty ifTrue: [1] ifFalse: [list size])] applyWith: {}.</
=={{header|Smalltalk}}==
<
| numbers |
Line 2,226 ⟶ 3,610:
(numbers inject: 0 into: [:sumSoFar :eachElement | sumSoFar + eachElement]) / numbers size ]
) displayNl.
</syntaxhighlight>
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.
</syntaxhighlight>
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.
</syntaxhighlight>
or
<
| numbers |
numbers := #(1 2 3 4 5 6 7 8).
numbers average displayNl.
</syntaxhighlight>
=={{header|SNOBOL4}}==
Line 2,257 ⟶ 3,641:
{{works with|CSnobol}}
<
avg i = i + 1; sum = sum + a<i> :s(avg)
avg = 1.0 * sum / prototype(a) :(return)
Line 2,270 ⟶ 3,654:
output = '[' str '] -> ' avg(arr)
output = '[ ] -> ' avg(empty)
end</
Output:
<pre>[1 2 3 4 5 6 7 8 9 10] -> 5.5
[ ] -> 0.</pre>
=={{header|SQL}}==
Tested on Oracle 11gR2, the more limited the tool, the more resourceful one becomes :)
<syntaxhighlight lang="sql">
create table "numbers" ("datapoint" integer);
insert into "numbers" select rownum from tab;
select sum("datapoint")/count(*) from "numbers";
</syntaxhighlight>
...or...
<syntaxhighlight lang="sql">select avg("datapoint") from "numbers";</syntaxhighlight>
=={{header|Standard ML}}==
These functions return a real:
<
| 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
Line 2,292 ⟶ 3,688:
would rather be handled by an exception.
<
| mean_reals xs = let
val (total, length) =
Line 2,311 ⟶ 3,707:
in
(real total / length)
end;</
=={{header|Stata}}==
=== Mean of a dataset variable ===
Illustration of the mean on the population (in millions) in january 2016 of a few european countries (source [http://appsso.eurostat.ec.europa.eu/nui/show.do?dataset=demo_gind&lang=fr Eurostat]).
<syntaxhighlight lang="text">clear all
input str20 country population
Belgium 11311.1
Bulgaria 7153.8
"Czech Republic" 10553.8
Denmark 5707.3
Germany 82175.7
Estonia 1315.9
Ireland 4724.7
Greece 10783.7
end
. 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</syntaxhighlight>
=== Mean in Mata ===
<syntaxhighlight lang="stata">mata
a=11311.1\7153.8\10553.8\5707.3\
82175.7\1315.9\4724.7\10783.7
mean(a)
16715.75</syntaxhighlight>
=={{header|Swift}}==
<syntaxhighlight lang="swift">func meanDoubles(s: [Double]) -> Double {
return s.reduce(0, +) / Double(s.count)
}
func meanInts(s: [Int]) -> Double {
return meanDoubles(s.map{Double($0)})
}</syntaxhighlight>
=={{header|Tcl}}==
<
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</
=={{header|TI-83 BASIC}}==
<syntaxhighlight lang="ti83b">Mean(Ans</syntaxhighlight>
=={{header|TI-89 BASIC}}==
<
=={{header|Trith}}==
<
[3 1 4 1 5 9] mean</
=={{header|
<syntaxhighlight lang="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( [] ) );
</syntaxhighlight>
=={{header|UNIX Shell}}==
1) First solution with bash (V >= 3), works with floats :
<syntaxhighlight lang="bash1">echo "`cat f | paste -sd+ | bc -l` / `cat f | wc -l`" | bc -l
</syntaxhighlight>
<syntaxhighlight lang="bash1">cat f
1
2
4
8
16
-200
echo "`cat f | paste -sd+ | bc -l`/`cat f | wc -l`" | bc -l
-28.16666666666666666666
cat f
1.109434
2
4.5
8.45
16
-200
400.56
33.23134771428571428571
</syntaxhighlight>
2) This example uses <tt>expr</tt>, so it only works with integers. It checks that each string in the list is an integer.
<
if expr $# >/dev/null; then
(count=0
Line 2,384 ⟶ 3,852:
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</
=={{header|UnixPipes}}==
{{incorrect|UnixPipes|There is a race between parallel commands. <code>cat count</code> might try to read the file before <code>wc -l >count</code> 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 <tt>count</tt> in the current directory.
{{works with|bash}}
<syntaxhighlight 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 >(wc -l > count) | fold sum | xargs echo "scale=5;(1/" $(cat count) ") * " | bc
}
(echo 3; echo 1; echo 4) | mean</syntaxhighlight>
=={{header|Ursa}}==
<syntaxhighlight lang="ursa">#
# arithmetic mean
#
decl int<> input
decl int i
for (set i 1) (< i (size args)) (inc i)
append (int args<i>) input
end for
out (/ (+ input) (size input)) endl console</syntaxhighlight>
=={{header|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 flo
Line 2,396 ⟶ 3,905:
#cast %e
example = mean <5.,3.,-2.,6.,-4.></
output:
<pre>1.600000e+00</pre>
=={{header|V}}==
<
[sum 0 [+] fold].
dup sum
swap size [[1 <] [1]] when /
].</
=={{header|Vala}}==
Using array to hold the numbers of the list:
<
double arithmetic(double[] list){
double mean;
Line 2,436 ⟶ 3,944:
stdout.printf("%s\n", mean_zero.to_string());
}
</syntaxhighlight>
Output:
Line 2,443 ⟶ 3,951:
0
</pre>
=={{header|VBA}}==
<syntaxhighlight lang="vb">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 If
End Function
Public 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 leng
End Sub</syntaxhighlight>{{out}}
<pre>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</pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Function mean(arr)
size = UBound(arr) + 1
mean = 0
For i = 0 To UBound(arr)
mean = mean + arr(i)
Next
mean = mean/size
End Function
'Example
WScript.Echo mean(Array(3,1,4,1,5,9))
</syntaxhighlight>
{{Out}}
<pre>3.83333333333333</pre>
=={{header|Vedit macro language}}==
The numeric data is stored in current edit buffer as ASCII strings, one value per line.
<
#2 = 0 // Count
BOF
Line 2,455 ⟶ 4,017:
}
if (#2) { #1 /= #2 }
Num_Type(#1)</
=={{header|Vim Script}}==
Throws an exception if the list is empty.
<
if empty(a:lst)
throw "Empty"
Line 2,468 ⟶ 4,030:
endfor
return sum / len(a:lst)
endfunction</
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import math
import arrays
fn main() {
for v in [
[]f64{}, // mean returns ok = false
[math.inf(1), math.inf(1)], // answer is +Inf
// answer is NaN, and mean returns ok = true, indicating NaN
// is the correct result
[math.inf(1), math.inf(-1)],
[f64(3), 1, 4, 1, 5, 9],
[f64(10), 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11],
[f64(10), 20, 30, 40, 50, -100, 4.7, -11e2],
] {
println("Vector: $v")
m := arrays.fold(v, 0.0, fn(r f64, v f64) f64 { return r+v })/v.len
println("Mean of $v.len numbers is $m\n")
}
}</syntaxhighlight>
{{out}}
<pre>Vector: []
Mean of 0 numbers is nan
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: [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.66</pre>
=={{header|Wart}}==
<syntaxhighlight lang="python">def (mean l)
sum.l / len.l</syntaxhighlight>
Example run:
<pre>mean '(1 2 3)
=> 2</pre>
=={{header|WDTE}}==
<syntaxhighlight lang="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));</syntaxhighlight>
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:
<syntaxhighlight lang="wdte">mean [1; 2; 3] -- io.writeln io.stdout;</syntaxhighlight>
Output:
<pre>2</pre>
=={{header|Wortel}}==
<
; using a fork (sum divided-by length)
mean1 @(@sum / #)
Line 2,482 ⟶ 4,111:
!mean2 [3 1 4 1 5 9 2]
]]
}</
Returns:
<pre>[3.5714285714285716 3.5714285714285716]</pre>
=={{header|Wren}}==
<syntaxhighlight lang="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</syntaxhighlight>
=={{header|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 <tt>nil</tt>, equivalent to the empty list or logical <tt>false</tt>.
<syntaxhighlight lang="lisp">(defun mean (v)
(if (= (vector-length v) 0)
nil
(let ((l (vector->list v)))
(/ (apply + l) (length l)))))</syntaxhighlight>
=={{header|XPL0}}==
<
code real RlOut=48;
Line 2,503 ⟶ 4,149:
[Test:= [1.0, 2.0, 5.0, -5.0, 9.5, 3.14159];
RlOut(0, Mean(Test, 6)); CrLf(0);
]</
Output:
Line 2,509 ⟶ 4,155:
2.60693
</pre>
=={{header|XSLT}}==
Where <code>$values</code> is some variable indicating a set of nodes containing numbers, the average is given by the XPath expression:
<syntaxhighlight lang="xpath">sum($values) div count($values)</syntaxhighlight>
===Runnable example===
<syntaxhighlight lang="xml"><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></syntaxhighlight>
Sample input:
<syntaxhighlight lang="xml"><numbers>
<!-- Average is 2.4 -->
<number>1</number>
<number>1</number>
<number>2</number>
<number>3</number>
<number>5</number>
</numbers></syntaxhighlight>
=={{header|Yorick}}==
<
if(is_void(x)) return 0;
return x(*)(avg);
}</
=={{header|zkl}}==
Converts int to floats (implicitly):
<syntaxhighlight lang="zkl">fcn mean(a,b,c,etc){ z:=vm.arglist; z.reduce('+,0.0)/z.len() }
mean(3,1,4,1,5,9); //-->3.83333
mean(); //-->Exception thrown: MathError(NaN (Not a number))</syntaxhighlight>
To pass in a vector/list:
<
meanV(T(3,1,4,1,5,9)); // --> 3.83333</syntaxhighlight>
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: average
case: 1
input: [2,3,10]
output: 5
case: 2
input: [7,11]
output: 9
</syntaxhighlight>
=={{header|zonnon}}==
<syntaxhighlight lang="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.
</syntaxhighlight>
{{out}}
<pre>
</pre>
|