Averages/Arithmetic mean: Difference between revisions

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

{{libheader|Action! Tool Kit}}

PROC Mean(INT ARRAY a INT count REAL POINTER result)

Test(a3,1)

Test(a3,0)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Arithmetic_mean.png Screenshot from Atari 8-bit computer]

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

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

[https://mlochbaum.github.io/BQN/try.html#code=QXZnIOKGkCArwrTDt+KJoAoKQXZnIDHigL8y4oC/M+KAvzQ= Try It!]

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

=={{header|C sharp|C#}}==

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

(when sequence

'''With Loop'''

(when list

(/ (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 ]

call mean f[] r

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

ELENA 5.0:

extension op

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

(/ (float (apply '+ lst)) (length lst)))

{{libheader|Calc}}

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

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

{{works with|langur|0.6.6}}

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

}