Averages/Arithmetic mean: Difference between revisions

{{task|Probability and statistics}}

 

 

Write a program to find the [[wp:arithmetic mean|mean]] (arithmetic average) of a numeric vector.

 

=={{header|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/%

{{out}}

<pre>

=={{header|11l}}==

{{trans|Python}}

R sum(x) / Float(x.len)

 

{{out}}

<pre>

=={{header|360 Assembly}}==

Compact and functional.

USING AVGP,12

LR 12,15

Z DC CL80' '

U DS CL2

{{out}}

<pre> 5.50</pre>

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

TAY

PLA

 

=={{header|8th}}==

: avg \ a -- avg(a)

dup ' n:+ 0 a:reduce

[ 10 ] avg . cr

bye

Output is:<br>

2.54395<br>

 

=={{header|ACL2}}==

(if (endp xs)

(mv 0 0)

(mv-let (n d)

(mean-r xs)

 

=={{header|ActionScript}}==

{

var sum:Number = 0;

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;

 

Put(Item => Mean(A (1..0)), Fore => 1, Exp => 0);

New_Line;

Output:

3.83333

 

=={{header|Aime}}==

mean(list l)

{

 

0;

 

=={{header|ALGOL 68}}==

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

[6]REAL test := (1.0, 2.0, 5.0, -5.0, 9.5, 3.14159);

print((mean(test),new line))

 

=={{header|ALGOL W}}==

% procedure to find the mean of the elements of a vector. %

% As the procedure can't find the bounds of the array for itself, %

r_format := "A"; r_w := 10; r_d := 2; % set fixed point output %

write( mean( numbers, 1, 5 ) );

 

=={{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)

WriteF('mean \s\n',

RealF(s,mean([1.0, 2.0, 3.0, 4.0, 5.0]), 2))

 

=={{header|AntLang}}==

AntLang has a built-in avg function.

 

=={{header|APL}}==

{{works with|APL2}}

(+/X)÷⍴X

 

=={{header|AppleScript}}==

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.

 

set len to (count listOfNumbers)

if (len is 0) then return missing value

end average

 

 

{{output}}

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 framework "Foundation"

 

end average

 

 

{{output}}

 

=={{header|Applesoft BASIC}}==

0 READ V$

1 IF LEN(V$) = 0 THEN END

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

 

=={{header|Arturo}}==

 

 

{{out}}

 

 

=={{header|Astro}}==

mean(1..10)

mean([])

 

=={{header|AutoHotkey}}==

Loop, % i {

Random, v, -3.141592, 3.141592

sum += v

}

 

=={{header|AWK}}==

#!/usr/local/bin/gawk -f

 

print mean(nothing)

}

 

{{out}}

=={{header|Babel}}==

 

 

{{Out}}

 

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

sum = 0;

FOR i = LBOUND(nums) TO UBOUND(nums)

ELSE

PRINT 0

 

==={{header|BBC BASIC}}===

 

To calculate the mean of an array:

REM specific functions for the array/vector types

DEF FN_Mean_Arithmetic#(n#())

= SUM(n#()) / (DIM(n#(),1)+1)

[[User:MichaelHutton|Michael Hutton]] 14:02, 29 May 2011 (UTC)

 

==={{header|IS-BASIC}}===

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)

170 NEXT

180 LET AM=T/SIZE(A)

 

=={{header|bc}}==

Uses the current scale for calculating the mean.

auto i, s

 

}

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

 

=={{header|blz}}==

:mean(vec)

vec.fold_left(0, (x, y -> x + y)) / vec.length()

 

=={{header|Bracmat}}==

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

(mean1=

sum length n

| !sum*!length^-1

);

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

( :?test

& 1000000:?Length

& out$mean1$!test

& out$mean2$!test

 

=={{header|Brat}}==

true? list.empty?, 0, { list.reduce(0, :+) / list.length }

}

 

 

=={{header|Burlesque}}==

 

blsq ) {1 2 2.718 3 3.142}av

2.372

blsq ) {}av

NaN

 

=={{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)

 

return 0;

mean[1, 2, 2.718, 3, 3.142] = 2.372

mean[1, 2, 2.718, 3] = 2.1795

</pre>

 

using System.Linq;

 

Console.WriteLine(new[] { 1, 2, 3 }.Average());

}

 

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

 

class Program

return d / nums.Length;

}

 

=={{header|C++}}==

{{libheader|STL}}

 

double mean(const std::vector<double>& numbers)

sum += *i;

return sum / numbers.size();

 

Shorter (and more idiomatic) version:

 

#include <algorithm>

 

return 0;

return std::accumulate(numbers.begin(), numbers.end(), 0.0) / numbers.size();

 

Idiomatic version templated on any kind of iterator:

 

#include <algorithm>

 

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

Pour contents of mixing bowl into baking dish.

 

 

=={{header|Clojure}}==

 

Returns a [http://clojure.org/data_structures ratio]:

(if (empty? sq)

0

 

Returns a float:

(if (empty? sq)

0

 

=={{header|COBOL}}==

Intrinsic function:

 

Sample implementation:

PROGRAM-ID. find-mean.

 

 

GOBACK

 

=={{header|Cobra}}==

 

class Rosetta

def mean(ns as List<of number>) as number

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:

 

=={{header|CoffeeScript}}==

mean = (array) ->

return 0 if array.length is 0

alert mean [1]

 

=={{header|Common Lisp}}==

'''With Reduce'''

 

 

'''With Loop'''

(/ (loop for i in list sum i)

 

=={{header|Crystal}}==

def mean(arr) : Float64

arr.sum / arr.size.to_f

 

=={{header|D}}==

===Imperative Version===

real sum = 0.0;

int count;

data = [3, 1, 4, 1, 5, 9];

writeln("Mean: ", data.mean);

{{out}}

<pre>mean: 0

mean: 3.83333</pre>

===More Functional Version===

 

real mean(Range)(Range r) pure nothrow @nogc {

writeln("Mean: ", (int[]).init.mean);

writeln("Mean: ", [3, 1, 4, 1, 5, 9].mean);

{{out}}

<pre>Mean: 0

===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!T) {

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

 

=={{header|Dart}}==

 

void main(){

print(mean([1,2,3,4,5,6,7]));

{{out}}

<pre>4.0</pre>

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

 

 

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

 

zd0=qsn [stack length = n]sz

1k [precision can be altered]sz

[+z1<+]ds+x[Sum: ]Pp

ln/[Mean: ]Pp

 

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:

 

Sum: 18

Mean: 3.6

Sample size: 5

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(Mean(TDoubleDynArray.Create()));

Writeln(Mean(TDoubleDynArray.Create(1,2,3,4,5)));

 

=={{header|Dyalect}}==

 

var acc = .0

var len = 0

}

 

 

=={{header|E}}==

Slightly generalized to support any object that allows iteration.

 

var count := 0

var sum := 0

}

return sum / 1.max(count)

 

=={{header|EasyLang}}==

.

f[] = [ 1 2 3 4 5 6 7 8 ]

 

=={{header|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

😁 warning: mean : zero-divide : empty-sequence

→ 0

 

=={{header|ECL}}==

AveVal(SET OF INTEGER s) := AVE(s);

SetVals := [14,9,16,20,91];

AveVal(SetVals) //returns 30.0 ;

 

=={{header|Elena}}==

 

extension op

while (enumerator.next())

{

count += 1;

};

"Arithmetic mean of {",array.asEnumerable(),"} is ",

array.average()).readChar()

{{out}}

<pre>

 

=={{header|Elixir}}==

def mean(list), do: Enum.sum(list) / length(list)

 

=={{header|Emacs Lisp}}==

 

 

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

atom sum

if length(s) = 0 then

sequence test

test = {1.0, 2.0, 5.0, -5.0, 9.5, 3.14159}

 

=={{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.

=={{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.

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

 

Checking this:

val it : float = 10.86666667

> mean_series [] ;;

 

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

 

=={{header|Factor}}==

 

: arithmetic-mean ( seq -- n )

 

Tests:

 

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Fish}}==

v< +<>0n; >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>

 

=={{header|Forth}}==

0e

dup 0= if 2drop exit then

 

create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,

 

=={{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

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

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

Print "Press any key to quit the program"

Sleep

 

{{out}}

=={{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

 

=={{header|GAP}}==

local n;

n := Length(v);

 

Mean([3, 1, 4, 1, 5, 9]);

 

=={{header|GEORGE}}==

0

1, n rep (i)

]

n div

Output:

<pre>

This works for arrays of integers.

 

DIM a%(10)

FOR i%=0 TO 10

RETURN sum/size%

ENDFUNC

 

=={{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 (

}

}

{{out}}

<pre>

 

=={{header|Groovy}}==

 

Test Program:

println avg([2,2,2,4,2])

 

Output:

=={{header|Haskell}}==

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

mean [] = 0

 

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

 

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

 

 

import Data.List (foldl') --'

 

main :: IO ()

 

=={{header|HicEst}}==

 

vec = $ - 1/2 ! 0.5 ... 99.5

mean = SUM(vec) / LEN(vec) ! 50

 

=={{header|Hy}}==

Returns <tt>None</tt> if the input is of length zero.

(if xs

 

=={{header|Icon}} and {{header|Unicon}}==

every (s := 0) +:= !args

write((real(s)/(0 ~= *args)) | 0)

 

Sample outputs:

If truly only the mean is wanted, one could use

 

 

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

 

; ==>

 

which are mean, variance, skewness and kurtosis.

=={{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

x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers

mean x

 

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.

0

mean1 x

 

=={{header|Java}}==

{{works with|Java|1.5+}}

 

double sum = 0.0;

for (double x : arr) {

}

return sum / arr.length;

 

=={{header|JavaScript}}==

===ES5===

 

{

var sum = 0, i;

 

alert( mean( [1,2,3,4,5] ) ); // 3

 

Using the native function `.forEach()`:

var sum = 0;

array.forEach(function(value){

}

 

 

Using the native function `.reduce()`:

return !array.length ? 0

: array.reduce(function(pre, cur, i) {

alert( mean( [1,2,3,4,5] ) ); // 3

alert( mean( [] ) ); // 0

 

Extending the `Array` prototype:

return !this.length ? 0

: this.reduce(function(pre, cur, i) {

alert( [1,2,3,4,5].mean() ); // 3

alert( [].mean() ); // 0

 

 

{{libheader|Functional}}

{

return a.length ? Functional.reduce('+', 0, a) / a.length : 0;

 

 

===ES6===

 

 

// mean :: [Num] => (Num | NaN)

return mean(sample);

 

 

{{Out}}

 

=={{header|jq}}==

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

 

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:

else add/length

 

=={{header|Julia}}==

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

2.0

julia> mean(1:10)

5.5

julia> mean([])

 

=={{header|K}}==

mean 1 2 3 5 7

3.6

mean@!0 / empty array

 

=={{header|Kotlin}}==

Kotlin has builtin functions for some collection types.

Example:

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

 

=={{header|KQL}}==

let dataset = datatable(values:real)[

1, 1.5, 3, 5, 6.5];

 

dataset|summarize avg(values)

 

Output:

 

=={{header|Lambdatalk}}==

{def mean

{lambda {:s}

{mean {S.serie 0 1000}}

-> 500

 

=={{header|langur}}==

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

 

 

writeln " custom: ", .mean([7, 3, 12])

 

{{out}}

 

=={{header|Lasso}}==

not #a->size ? return 0

local(x = 0.0)

}

 

 

=={{header|LFE}}==

=== 1-Arity ===

 

(defun mean (data)

(/ (lists:sum data)

(length data)))

 

Usage:

1.0

> (mean '(1 2))

6.0

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

 

=== n-Arity ===

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

 

`(/ (lists:sum ,args)

 

Usage:

 

42.0

> (mean 18 66)

42.0

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

 

=={{header|Liberty BASIC}}==

dim nums(total)

for i = 1 to total

if total=0 then mean=0 else mean=sum/total

print "Arithmetic mean: ";mean

 

=={{header|Limbo}}==

 

include "sys.m";

n += a[i];

return n / (real len a);

 

=={{header|Lingo}}==

on mean (v)

case ilk(v) of

end repeat

return float(sum)/cnt

 

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

 

=={{header|LiveCode}}==

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

 

=={{header|Logo}}==

if empty? :l [output 0]

output quotient apply "sum :l count :l

end

 

=={{header|Logtalk}}==

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

:- object(averages).

 

 

:- end_object.

Sample output:

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

Mean = 5.5

yes

 

=={{header|LSL}}==

integer MAX_VALUE = 100;

default {

llOwnerSay(" Sum Squares: "+(string)llListStatistics(LIST_STAT_SUM_SQUARES, lst));

}

Output:

<pre>

 

=={{header|Lua}}==

if type(numlist) ~= 'table' then return numlist end

num = 0

end

 

 

=={{header|Lucid}}==

 

where

sum = first(x) fby sum + next(x);

n = 1 fby n + 1;

avg = sum / n;

 

=={{header|M4}}==

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

 

=={{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.

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

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

This can be called as in the following examples.

> mean( 1, 2, 3, 4, 5 );

3

> mean(); # again, an exception is raised

Error, (in mean) numeric exception: division by zero

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

Examples:

Mean[{3.2,4.5,5.9}]

Mean[{-4, 1.233}]

Mean[{}]

Mean[{1/2,1/3,1/4,1/5}]

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

 

=={{header|Mathprog}}==

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

 

end;

 

When run this produces:

 

GLPSOL: GLPK LP/MIP Solver, v4.47

Parameter(s) specified in the command line:

The arithmetic mean of the integers from 1 to 1048575 is 524288.000000

Model has been successfully processed

 

=={{header|MATLAB}}==

meanValue = mean(setOfValues);

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

(

total = 0

)

 

 

=={{header|Mercury}}==

:- interface.

 

mean(Ns @ [_ | _]) = foldl((+), Ns, 0.0) / float(length(Ns)).

 

 

Alternatively, we could use inst subtyping to ensure we get a compilation error if the

mean function is called with an empty list.

 

 

 

=={{header|min}}==

Returns <code>nan</code> for an empty quotation.

{{out}}

 

=={{header|MiniScript}}==

 

 

avg = function(arr)

end function

 

 

=={{header|МК-61/52}}==

 

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

 

=={{header|Modula-2}}==

 

VAR avg : REAL;

InOut.WriteReal (avg, 8, 2);

InOut.WriteLn

OR

 

(* Calculate the average over 'Samples' values, stored in array 'Data'. *)

END;

RETURN sum / FLOAT(Samples)

 

=={{header|MUMPS}}==

;X is assumed to be a list of numbers separated by "^"

QUIT:'$DATA(X) "No data"

SET S=0,I=1

FOR QUIT:I>$L(X,"^") SET S=S+$P(X,"^",I),I=I+1

<pre>USER>W $$MEAN^ROSETTA

No data

 

=={{header|Nanoquery}}==

sum = 0

for n in lst

def average(x)

return sum(x) / len(x)

 

=={{header|Nemerle}}==

using System.Console;

using Nemerle.Collections;

WriteLine("Mean of [1 .. 10]: {0}", ArithmeticMean($[1 .. 10]));

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

]

return vectors

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

(if (empty? Lst)

0

(Mean (sequence 1 1000))-> 500

 

=={{header|Nial}}==

in the standard way, mean is

 

mean 6 2 4

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

 

mean is / [sum, dtally]

 

mean []

 

=={{header|Nim}}==

{{trans|C}}

 

proc mean(xs: openArray[float]): float =

for i in 0..5:

echo "mean of first ", v.len, " = ", formatFloat(mean(v), precision = 0)

Output:

<pre>mean of first 5 = 2.372

 

=={{header|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 ;

3.4 2.3 .01 2.0 2.1 avg .

=> 1.9619999999999997

 

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE AvgMean;

IMPORT Out;

Out.Fixed(Avg(ary),4,2);Out.Ln

END AvgMean.

Output:

<pre>

 

=={{header|Objeck}}==

function : native : PrintAverage(values : FloatVector) ~ Nil {

values->Average()->PrintLine();

}

 

=={{header|OCaml}}==

These functions return a float:

 

| [] -> 0.

| xs -> List.fold_left (+.) 0. xs /. float_of_int (List.length xs)

 

 

the previous code is easier to read and understand, though if you wish

would rather be handled by an exception.

 

if xs = [] then

invalid_arg "empty list"

in

(float total /. length)

 

=={{header|Octave}}==

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;

 

disp(omean([]));

 

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;

 

=={{header|Oforth}}==

 

x sum

x size dup ifZero: [ 2drop null ] else: [ >float / ]

 

{{out}}

 

=={{header|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)

end

return sum/numbers~items

Output:

<pre>

=={{header|Oz}}==

A version working on floats:

fun {Mean Xs}

{FoldL Xs Number.'+' 0.0} / {Int.toFloat {Length Xs}}

end

in

 

=={{header|PARI/GP}}==

if(#v,vecsum(v)/#v)

 

=={{header|Pascal}}==

 

function DoMean(vector: array of double): double;

writeln (']');

writeln('Mean: ', DoMean(vector):10:8);

 

Output:

Alternative version using the Math unit:

 

uses math;

const

mean := sum(vector)/length(vector);

writeln('Mean: ', mean:10:8);

 

=={{header|Perl}}==

@_ or return 0;

my $sum = 0;

}

 

=={{header|Phix}}==

 

=={{header|Phixmonti}}==

 

=={{header|PHP}}==

if ($nums)

echo array_sum($nums) / count($nums), "\n";

else

 

=={{header|PicoLisp}}==

(if (atom Lst)

0

Output:

<pre>: (mean (range 1 1000))

 

=={{header|PL/I}}==

 

=={{header|Plain English}}==

Start up.

Demonstrate finding the arithmetic mean.

If the entry's next is not nil, append ", " to the string.

Put the entry's next into the entry.

{{out}}

<pre>

=={{header|Pop11}}==

 

lvars n = length(v), i, s = 0;

if n = 0 then

endif;

return(s/n);

 

=={{header|PostScript}}==

/findmean{

/x exch def

sum ==

}def

 

{{libheader|initlib}}

{{works with|Ghostscript}}

/avg {

dup length

} ifte

}.

 

=={{header|PowerShell}}==

The hard way by calculating a sum and dividing:

if ($x.Count -eq 0) {

return 0

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

return ($x | Measure-Object -Average).Average

}

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|6.6}}

 

mean(List, Mean) :-

length(List, Length),

sumlist(List, Sum),

Mean is Sum / Length.

 

=={{header|PureBasic}}==

Protected sum=0

 

ProcedureReturn sum / ListSize(number())

; Depends on programm if zero check needed, returns nan on division by zero

 

=={{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]))

 

{{out}}

 

 

{{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]))

 

{{out}}

(Notice how the second call gave the wrong result)

 

 

{{works with|Python|2.4}}

if len(data)==0:

return 0

else:

return sum(data)/float(len(data))

 

{{out}}

 

{{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.)

>>> mean([1e20,-1e-20,3,1,4,1,5,9,-1e20,1e-20])

2.3

>>> big = 10**10000

>>> mean([Decimal(big), Decimal(-big), 3, 1, 4, 1, 5, 9, 1/Decimal(big), -1/Decimal(big)])

 

=={{header|Q}}==

A built-in solution is <tt>avg</tt>. An implementation of it could be:

 

=={{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}}==

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)

(mean '(2 2 4 4)) ; -> 3

(mean #(3 4 5 8)) ; -> 5

 

=={{header|Raku}}==

{{works with|Rakudo|2015.10-11}}

 

 

=={{header|REBOL}}==

Title: "Arithmetic Mean (Average)"

URL: http://rosettacode.org/wiki/Average/Arithmetic_mean

print [mold x: [3 1 4 1 5 9] "->" average x]

print [mold x: [1000 3 1 4 1 5 9 -1000] "->" average x]

 

Output:

[1000 3 1 4 1 5 9 -1000] -> 2.875

[1E+20 3 1 4 1 5 9 -1E+20] -> 0.0</pre>

 

=={{header|REXX}}==

 

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

parse arg @.1; if @.1='' then do; #=6 /*vector from the C.L.?*/

@.1 = 10 9 8 7 6 5 4 3 2 1

 

if #==0 then return 'N/A: ───[no numeric values.]' /*No nums? Return N/A*/

'''output''' &nbsp; when using the (internal) lists:

<pre>

 

=={{header|Ring}}==

nums = [1,2,3,4,5,6,7,8,9,10]

sum = 0

next

return sum/len(numbers)

 

 

 

 

=={{header|Ruby}}==

nums.sum(0.0) / nums.size

end

ary = nums[0,i]

puts "array size #{ary.size} : #{mean(ary)}"

{{out}}

<pre>

 

=={{header|Run BASIC}}==

dim value(numArray)

for i = 1 to numArray

next

if totValue <> 0 then mean = totValue/numArray

 

=={{header|Rust}}==

arr.iter().fold(0.0, |p,&q| p + q)

}

let w = &[];

println!("mean of {:?}: {:?}", w, mean(w));

Output:

<pre>mean of [2, 3, 5, 7, 13, 21, 33, 54]: 17.25

=={{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;

#OUT + VECOPS::mean(v) + "\n";

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

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

 

=={{header|Scheme}}==

(if (null? l)

0

 

> (mean (list 3 1 4 1 5 9))

 

=={{header|Seed7}}==

include "float.s7i";

 

begin

writeln(mean(numVector));

 

=={{header|Sidef}}==

}

 

{{out}}

2.875

3.674

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

| numbers |

 

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

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

avg i = i + 1; sum = sum + a<i> :s(avg)

avg = 1.0 * sum / prototype(a) :(return)

output = '[' str '] -> ' avg(arr)

output = '[ ] -> ' avg(empty)

 

Output:

=={{header|SQL}}==

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

create table "numbers" ("datapoint" integer);

 

 

select sum("datapoint")/count(*) from "numbers";

...or...

 

=={{header|Standard ML}}==

These functions return a real:

 

| mean_reals xs = foldl op+ 0.0 xs / real (length xs);

 

 

The previous code is easier to read and understand, though if you want

would rather be handled by an exception.

 

| mean_reals xs = let

val (total, length) =

in

(real total / length)

 

=={{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]).

input str20 country population

Belgium 11311.1

. quietly summarize population

. display r(mean)

 

=== Mean in Mata ===

a=11311.1\7153.8\10553.8\5707.3\

82175.7\1315.9\4724.7\10783.7

 

mean(a)

 

=={{header|Swift}}==

return s.reduce(0, +) / Double(s.count)

}

func meanInts(s: [Int]) -> Double {

return meanDoubles(s.map{Double($0)})

 

=={{header|Tcl}}==

proc mean args {

if {[set num [llength $args]] == 0} {return 0}

expr {[tcl::mathop::+ {*}$args] / double($num)}

}

 

=={{header|TI-83 BASIC}}==

 

=={{header|TI-89 BASIC}}==

 

 

=={{header|Trith}}==

 

 

=={{header|TypeScript}}==

function mean(numbersArr)

{

alert( mean( [1,2,3,4,5] ) );

alert( mean( [] ) );

 

=={{header|UNIX Shell}}==

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

1

2

echo "`cat f | paste -sd+ | bc -l`/`cat f | wc -l`" |bc -l

33.23134771428571428571

 

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

printf "test 4: "; mean -400 400 -1300 200 # -275

printf "test 5: "; mean - # expr: syntax error

 

=={{header|UnixPipes}}==

Uses [[ksh93]]-style process substitution. Also overwrites the file named <tt>count</tt> in the current directory.

{{works with|bash}}

b=$1;res=$2

echo "scale=5;$res+$b" | bc

}

 

 

=={{header|Ursa}}==

# arithmetic mean

#

end for

 

 

=={{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

 

#cast %e

 

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;

stdout.printf("%s\n", mean_zero.to_string());

}

 

Output:

 

=={{header|VBA}}==

Dim sum As Double, i As Integer

sum = 0: i = 0

Debug.Print "] = "; mean(v, leng)

Next leng

<pre>mean[1; 2; 2,178; 3; 3,142] = 0

mean[1; 2; 2,178; 3] = 0

 

=={{header|VBScript}}==

Function mean(arr)

size = UBound(arr) + 1

'Example

WScript.Echo mean(Array(3,1,4,1,5,9))

 

{{Out}}

=={{header|Vedit macro language}}==

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

#2 = 0 // Count

BOF

}

if (#2) { #1 /= #2 }

 

=={{header|Vim Script}}==

Throws an exception if the list is empty.

if empty(a:lst)

throw "Empty"

endfor

return sum / len(a:lst)

 

=={{header|Wart}}==

 

Example run:

 

=={{header|WDTE}}==

let a => import 'arrays';

 

a.stream nums

-> s.reduce [0; 0] (@ s p n => [+ (a.at p 0) 1; + (a.at p 1) n])

 

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:

 

Output:

 

=={{header|Wortel}}==

; using a fork (sum divided-by length)

mean1 @(@sum / #)

!mean2 [3 1 4 1 5 9 2]

]]

Returns:

<pre>[3.5714285714285716 3.5714285714285716]</pre>

 

=={{header|Wren}}==

static mean(arr) {

if (arr.count == 0) Fiber.abort("Length must be greater than zero")

}

}

 

=={{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>.

(if (= (vector-length v) 0)

nil

(let ((l (vector->list v)))

 

=={{header|XPL0}}==

code real RlOut=48;

 

[Test:= [1.0, 2.0, 5.0, -5.0, 9.5, 3.14159];

RlOut(0, Mean(Test, 6)); CrLf(0);

 

Output:

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

 

 

===Runnable example===

 

<xsl:output method="text"/>

 

<xsl:value-of select="sum($values) div count($values)"/>

</xsl:template>

 

Sample input:

 

<!-- Average is 2.4 -->

<number>1</number>

<number>3</number>

<number>5</number>

 

=={{header|Yorick}}==

if(is_void(x)) return 0;

return x(*)(avg);

 

=={{header|zkl}}==

Converts int to floats (implicitly):

mean(3,1,4,1,5,9); //-->3.83333

To pass in a vector/list:

 

=={{header|Zoea}}==

program: average

case: 1

input: [7,11]

output: 9

 

=={{header|zonnon}}==

module Averages;

type

write("arithmetic mean: ");writeln(ArithmeticMean(x):10:2)

end Averages.

{{out}}

<pre>