Averages/Arithmetic mean: Difference between revisions

Line 1:

;Task

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

Line 14:

=={{header|0815}}==

{x{+=<:2:x/%<:d:~$<:01:~><:02:~><:03:~><:04:~><:05:~><:06:~><:07:~><:08:

~><:09:~><:0a:~><:0b:~><:0c:~><:0d:~><:0e:~><:0f:~><:10:~><:11:~><:12:~>

Line 28:

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

<syntaxhighlight lang=11l>F average(x)

<syntaxhighlight lang="11l">F average(x)

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

Line 39:

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

Compact and functional.

<syntaxhighlight lang=360asm>AVGP CSECT

<syntaxhighlight lang="360asm">AVGP CSECT

USING AVGP,12

LR 12,15

Line 72:

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.

<syntaxhighlight lang=6502asm>ArithmeticMean: PHA

<syntaxhighlight lang="6502asm">ArithmeticMean: PHA

TYA

PHA ;push accumulator and Y register onto stack

Line 114:

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

: avg \ a -- avg(a)

dup ' n:+ 0 a:reduce

Line 131:

=={{header|ACL2}}==

<syntaxhighlight lang=~~Lisp~~>(defun mean-r (xs)

<syntaxhighlight lang="lisp">(defun mean-r (xs)

(if (endp xs)

(mv 0 0)

Line 147:

=={{header|Action!}}==

<syntaxhighlight lang=~~Action~~!>INCLUDE "D2:REAL.ACT" ;from the 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)

Line 202:

=={{header|ActionScript}}==

<syntaxhighlight lang=~~ActionScript~~>function mean(vector:Vector.<Number>):Number

<syntaxhighlight lang="actionscript">function mean(vector:Vector.<Number>):Number

{

var sum:Number = 0;

Line 212:

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

<syntaxhighlight lang=ada>with Ada.Float_Text_Io; use Ada.Float_Text_Io;

<syntaxhighlight lang="ada">with Ada.Float_Text_Io; use Ada.Float_Text_Io;

with Ada.Text_IO; use Ada.Text_IO;

Line 240:

=={{header|Aime}}==

<syntaxhighlight lang=aime>real

<syntaxhighlight lang="aime">real

mean(list l)

{

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

<syntaxhighlight lang=algol68>PROC mean = (REF[]REAL p)REAL:

<syntaxhighlight lang="algol68">PROC mean = (REF[]REAL p)REAL:

# Calculates the mean of qty REALs beginning at p. #

IF LWB p > UPB p THEN 0.0

Line 282:

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

<syntaxhighlight lang=algolw>begin

<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, %

Line 308:

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

<syntaxhighlight lang=amigae>PROC mean(l:PTR TO LONG)

<syntaxhighlight lang="amigae">PROC mean(l:PTR TO LONG)

DEF m, i, ll

ll := ListLen(l)

Line 325:

=={{header|AntLang}}==

AntLang has a built-in avg function.

=={{header|APL}}==

<syntaxhighlight lang=apl> X←3 1 4 1 5 9

<syntaxhighlight lang="apl"> X←3 1 4 1 5 9

(+/X)÷⍴X

3.833333333</syntaxhighlight>

Line 338:

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)

<syntaxhighlight lang="applescript">on average(listOfNumbers)

set len to (count listOfNumbers)

if (len is 0) then return missing value

Line 359:

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

<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later

use framework "Foundation"

Line 375:

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

<syntaxhighlight lang=~~ApplesoftBasic~~>REM COLLECTION IN DATA STATEMENTS, EMPTY DATA IS THE END OF THE COLLECTION

<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

Line 396:

=={{header|Arturo}}==

<syntaxhighlight lang=rebol>arr: [1 2 3 4 5 6 7]

<syntaxhighlight lang="rebol">arr: [1 2 3 4 5 6 7]

print average arr</syntaxhighlight>

Line 405:

=={{header|Astro}}==

<syntaxhighlight lang=astro>mean([1, 2, 3])

<syntaxhighlight lang="astro">mean([1, 2, 3])

mean(1..10)

mean([])

Line 411:

=={{header|AutoHotkey}}==

<syntaxhighlight lang=autohotkey>i = 10

<syntaxhighlight lang="autohotkey">i = 10

Loop, % i {

Random, v, -3.141592, 3.141592

Line 420:

=={{header|AWK}}==

<syntaxhighlight lang=awk>cat mean.awk

<syntaxhighlight lang="awk">cat mean.awk

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

Line 455:

=={{header|Babel}}==

Line 464:

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

<syntaxhighlight lang=qbasic>mean = 0

<syntaxhighlight lang="qbasic">mean = 0

sum = 0;

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

Line 481:

To calculate the mean of an array:

REM specific functions for the array/vector types

Line 514:

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

<syntaxhighlight lang=IS-~~BASIC~~>100 NUMERIC ARR(3 TO 8)

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

Line 527:

=={{header|bc}}==

Uses the current scale for calculating the mean.

<syntaxhighlight lang=bc>define m(a[], n) {

<syntaxhighlight lang="bc">define m(a[], n) {

auto i, s

Line 538:

=={{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 lang="befunge">&:0\:!v!:-1<

@./\$_\&+\^</syntaxhighlight>

=={{header|blz}}==

:mean(vec)

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

Line 549:

=={{header|Bracmat}}==

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

(mean1=

sum length n

Line 576:

</syntaxhighlight>

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

( :?test

& 1000000:?Length

Line 585:

=={{header|Brat}}==

<syntaxhighlight lang=brat>mean = { list |

<syntaxhighlight lang="brat">mean = { list |

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

}

Line 593:

=={{header|Burlesque}}==

blsq ) {1 2 2.718 3 3.142}av

2.372

Line 603:

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

<syntaxhighlight lang=bqn>Avg ← +´÷≠

<syntaxhighlight lang="bqn">Avg ← +´÷≠

Avg 1‿2‿3‿4</syntaxhighlight>

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

Line 613:

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

<syntaxhighlight lang=c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

double mean(double *v, int len)

Line 646:

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

<syntaxhighlight lang=csharp>using System;

<syntaxhighlight lang="csharp">using System;

using System.Linq;

Line 658:

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

<syntaxhighlight lang=csharp>using System;

<syntaxhighlight lang="csharp">using System;

class Program

Line 690:

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

<syntaxhighlight lang=cpp>#include <vector>

<syntaxhighlight lang="cpp">#include <vector>

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

Line 705:

Shorter (and more idiomatic) version:

<syntaxhighlight lang=cpp>#include <vector>

<syntaxhighlight lang="cpp">#include <vector>

#include <algorithm>

Line 717:

Idiomatic version templated on any kind of iterator:

<syntaxhighlight lang=cpp>#include <iterator>

<syntaxhighlight lang="cpp">#include <iterator>

#include <algorithm>

Line 730:

=={{header|Chef}}==

<syntaxhighlight lang=~~Chef~~>Mean.

<syntaxhighlight lang="chef">Mean.

Chef has no way to detect EOF, so rather than interpreting

Line 765:

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

<syntaxhighlight lang=lisp>(defn mean [sq]

<syntaxhighlight lang="lisp">(defn mean [sq]

(if (empty? sq)

0

Line 771:

Returns a float:

<syntaxhighlight lang=lisp>(defn mean [sq]

<syntaxhighlight lang="lisp">(defn mean [sq]

(if (empty? sq)

0

Line 778:

=={{header|COBOL}}==

Intrinsic function:

<syntaxhighlight lang=cobol>FUNCTION MEAN(some-table (ALL))</syntaxhighlight>

<syntaxhighlight lang="cobol">FUNCTION MEAN(some-table (ALL))</syntaxhighlight>

Sample implementation:

<syntaxhighlight lang=cobol> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. find-mean.

Line 812:

=={{header|Cobra}}==

class Rosetta

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

Line 835:

=={{header|CoffeeScript}}==

mean = (array) ->

return 0 if array.length is 0

Line 848:

'''With Reduce'''

<syntaxhighlight lang=lisp>(defun mean (&rest sequence)

<syntaxhighlight lang="lisp">(defun mean (&rest sequence)

(when sequence

(/ (reduce #'+ sequence) (length sequence))))</syntaxhighlight>

'''With Loop'''

<syntaxhighlight lang=lisp>(defun mean (list)

<syntaxhighlight lang="lisp">(defun mean (list)

(when list

(/ (loop for i in list sum i)

Line 859:

=={{header|Crystal}}==

<syntaxhighlight lang=ruby># Crystal will return NaN if an empty array is passed

<syntaxhighlight lang="ruby"># Crystal will return NaN if an empty array is passed

def mean(arr) : Float64

arr.sum / arr.size.to_f

Line 866:

=={{header|D}}==

===Imperative Version===

<syntaxhighlight lang=d>real mean(Range)(Range r) pure nothrow @nogc {

<syntaxhighlight lang="d">real mean(Range)(Range r) pure nothrow @nogc {

real sum = 0.0;

int count;

Line 893:

mean: 3.83333</pre>

===More Functional Version===

<syntaxhighlight lang=d>import std.stdio, std.algorithm, std.range;

<syntaxhighlight lang="d">import std.stdio, std.algorithm, std.range;

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

Line 909:

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

<syntaxhighlight lang=d>import std.stdio, std.conv, std.algorithm, std.math, std.traits;

<syntaxhighlight lang="d">import std.stdio, std.conv, std.algorithm, std.math, std.traits;

CommonType!(T, real) mean(T)(T[] n ...) if (isNumeric!T) {

Line 929:

=={{header|Dart}}==

<syntaxhighlight lang=d>num mean(List<num> l) => l.reduce((num p, num n) => p + n) / l.length;

<syntaxhighlight lang="d">num mean(List<num> l) => l.reduce((num p, num n) => p + n) / l.length;

void main(){

Line 940:

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

<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

<syntaxhighlight lang="dc">[[Nada Mean: ]Ppq]sq

zd0=qsn [stack length = n]sz

1k [precision can be altered]sz

Line 954:

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

<syntaxhighlight lang="dc">$ dc sample.dc amean.cd

Sum: 18

Mean: 3.6

Line 961:

=={{header|Delphi}}==

<syntaxhighlight lang=~~Delphi~~>program AveragesArithmeticMean;

<syntaxhighlight lang="delphi">program AveragesArithmeticMean;

{$APPTYPE CONSOLE}

Line 986:

=={{header|Dyalect}}==

<syntaxhighlight lang=dyalect>func avg(args...) {

<syntaxhighlight lang="dyalect">func avg(args...) {

var acc = .0

var len = 0

Line 1,002:

Slightly generalized to support any object that allows iteration.

<syntaxhighlight lang=e>def meanOrZero(numbers) {

<syntaxhighlight lang="e">def meanOrZero(numbers) {

var count := 0

var sum := 0

Line 1,013:

=={{header|EasyLang}}==

<lang>func mean . f[] r .

<syntaxhighlight lang="text">func mean . f[] r .

for i range len f[]

s += f[i]

Line 1,025:

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

Line 1,050:

=={{header|ECL}}==

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

Line 1,061:

=={{header|Elena}}==

ELENA 5.0:

<syntaxhighlight lang=elena>import extensions;

<syntaxhighlight lang="elena">import extensions;

extension op

Line 1,095:

=={{header|Elixir}}==

<syntaxhighlight lang=elixir>defmodule Average do

<syntaxhighlight lang="elixir">defmodule Average do

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

end</syntaxhighlight>

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

<syntaxhighlight lang=lisp>(defun mean (lst)

<syntaxhighlight lang="lisp">(defun mean (lst)

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

(mean '(1 2 3 4))</syntaxhighlight>

Line 1,106:

<syntaxhighlight lang=lisp>(let ((x '(1 2 3 4)))

<syntaxhighlight lang="lisp">(let ((x '(1 2 3 4)))

(calc-eval "vmean($1)" nil (append '(vec) x)))</syntaxhighlight>

=={{header|Erlang}}==

<syntaxhighlight lang=erlang>mean([]) -> 0;

<syntaxhighlight lang="erlang">mean([]) -> 0;

mean(L) -> lists:sum(L)/erlang:length(L).</syntaxhighlight>

=={{header|Euphoria}}==

<syntaxhighlight lang=~~Euphoria~~>function mean(sequence s)

<syntaxhighlight lang="euphoria">function mean(sequence s)

atom sum

if length(s) = 0 then

Line 1,134:

Assuming the values are entered in the A column, type into any cell which will not be part of the list:

<syntaxhighlight lang=excel>=AVERAGE(A1:A10)</syntaxhighlight>

<syntaxhighlight lang="excel">=AVERAGE(A1:A10)</syntaxhighlight>

Assuming 10 values will be entered, alternatively, you can just type:

<syntaxhighlight lang=excel>=AVERAGE(</syntaxhighlight>

<syntaxhighlight lang="excel">=AVERAGE(</syntaxhighlight>

and then select the start and end cells, not necessarily in the same row or column.

Line 1,159:

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

<syntaxhighlight lang="fsharp">let avg (a:float) (v:float) n =

a + (1. / ((float n) + 1.)) * (v - a)

Line 1,167:

Checking this:

<syntaxhighlight lang=fsharp> > mean_series [1; 8; 2; 8; 1; 7; 1; 8; 2; 7; 3; 6; 1; 8; 100] ;;

<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 [] ;;

Line 1,173:

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>

<syntaxhighlight lang="fsharp">List.average [4;1;7;5;8;4;5;2;1;5;2;5]</syntaxhighlight>

=={{header|Factor}}==

<syntaxhighlight lang=factor>USING: math math.statistics ;

<syntaxhighlight lang="factor">USING: math math.statistics ;

: arithmetic-mean ( seq -- n )

Line 1,183:

Tests:

<syntaxhighlight lang=factor>( scratchpad ) { 2 3 5 } arithmetic-mean >float

<syntaxhighlight lang="factor">( scratchpad ) { 2 3 5 } arithmetic-mean >float

3.333333333333333</syntaxhighlight>

=={{header|Fantom}}==

class Main

{

Line 1,210:

=={{header|Fish}}==

<syntaxhighlight lang=~~Fish~~>!vl0=?vl1=?vl&!

<syntaxhighlight lang="fish">!vl0=?vl1=?vl&!

v< +<>0n; >n;

>l1)?^&,n;</syntaxhighlight>

Line 1,219:

=={{header|Forth}}==

<syntaxhighlight lang=forth>: fmean ( addr n -- f )

<syntaxhighlight lang="forth">: fmean ( addr n -- f )

0e

dup 0= if 2drop exit then

Line 1,232:

=={{header|Fortran}}==

In ISO Fortran 90 or later, use the SUM intrinsic, the SIZE intrinsic and the MAX intrinsic (to avoid divide by zero):

<syntaxhighlight lang=fortran>real, target, dimension(100) :: a = (/ (i, i=1, 100) /)

<syntaxhighlight lang="fortran">real, target, dimension(100) :: a = (/ (i, i=1, 100) /)

real, dimension(5,20) :: b = reshape( a, (/ 5,20 /) )

real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array

Line 1,254:

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

Line 1,319:

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

<syntaxhighlight lang=gap>Mean := function(v)

<syntaxhighlight lang="gap">Mean := function(v)

local n;

n := Length(v);

Line 1,338:

=={{header|GEORGE}}==

<syntaxhighlight lang=~~GEORGE~~>R (n) P ;

<syntaxhighlight lang="george">R (n) P ;

0

1, n rep (i)

Line 1,364:

This works for arrays of integers.

<lang>

DIM a%(10)

FOR i%=0 TO 10

Line 1,393:

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.

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import (

Line 1,483:

=={{header|Groovy}}==

Test Program:

<syntaxhighlight lang=groovy>println avg(0..9)

<syntaxhighlight lang="groovy">println avg(0..9)

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

println avg ([])</syntaxhighlight>

Line 1,497:

=={{header|Haskell}}==

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

<syntaxhighlight lang=haskell>mean :: (Fractional a) => [a] -> a

<syntaxhighlight lang="haskell">mean :: (Fractional a) => [a] -> a

mean [] = 0

mean xs = sum xs / Data.List.genericLength xs</syntaxhighlight>

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

<syntaxhighlight lang=haskell>meanReals :: (Real a, Fractional b) => [a] -> b

<syntaxhighlight lang="haskell">meanReals :: (Real a, Fractional b) => [a] -> b

meanReals = mean . map realToFrac</syntaxhighlight>

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

<syntaxhighlight lang=haskell>{-# LANGUAGE BangPatterns #-}

<syntaxhighlight lang="haskell">{-# LANGUAGE BangPatterns #-}

import Data.List (foldl') --'

Line 1,528:

=={{header|HicEst}}==

<syntaxhighlight lang=hicest>REAL :: vec(100) ! no zero-length arrays in HicEst

<syntaxhighlight lang="hicest">REAL :: vec(100) ! no zero-length arrays in HicEst

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

Line 1,536:

=={{header|Hy}}==

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

<syntaxhighlight lang=clojure>(defn arithmetic-mean [xs]

<syntaxhighlight lang="clojure">(defn arithmetic-mean [xs]

(if xs

(/ (sum xs) (len xs))))</syntaxhighlight>

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

<syntaxhighlight lang=icon>procedure main(args)

<syntaxhighlight lang="icon">procedure main(args)

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

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

Line 1,557:

If truly only the mean is wanted, one could use

<syntaxhighlight lang=idl>x = [3,1,4,1,5,9]

<syntaxhighlight lang="idl">x = [3,1,4,1,5,9]

print,mean(x)</syntaxhighlight>

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

<syntaxhighlight lang=idl>print,moment(x)

<syntaxhighlight lang="idl">print,moment(x)

; ==>

3.83333 8.96667 0.580037 -1.25081</syntaxhighlight>

Line 1,572:

=={{header|J}}==

That is, sum divided by the number of items. The verb also works on higher-ranked arrays. For example:

<syntaxhighlight lang=j> mean 3 1 4 1 5 9

<syntaxhighlight lang="j"> mean 3 1 4 1 5 9

3.83333

mean $0 NB. $0 is a zero-length vector

Line 1,586:

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.

<syntaxhighlight lang=j>mean1=: 3 : 0

<syntaxhighlight lang="j">mean1=: 3 : 0

z=. 0

for_i. i.#y do. z=. z+i{y end.

Line 1,601:

<syntaxhighlight lang=java5>public static double avg(double... arr) {

<syntaxhighlight lang="java5">public static double avg(double... arr) {

double sum = 0.0;

for (double x : arr) {

Line 1,613:

===ES5===

<syntaxhighlight lang=javascript>function mean(array)

<syntaxhighlight lang="javascript">function mean(array)

{

var sum = 0, i;

Line 1,627:

Using the native function `.forEach()`:

<syntaxhighlight lang=javascript>function mean(array) {

<syntaxhighlight lang="javascript">function mean(array) {

var sum = 0;

array.forEach(function(value){

Line 1,638:

Using the native function `.reduce()`:

<syntaxhighlight lang=javascript>function mean(array) {

<syntaxhighlight lang="javascript">function mean(array) {

return !array.length ? 0

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

Line 1,650:

Extending the `Array` prototype:

<syntaxhighlight lang=javascript>Array.prototype.mean = function() {

<syntaxhighlight lang="javascript">Array.prototype.mean = function() {

return !this.length ? 0

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

Line 1,663:

<syntaxhighlight lang=javascript>function mean(a)

<syntaxhighlight lang="javascript">function mean(a)

{

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

Line 1,671:

===ES6===

<syntaxhighlight lang=~~JavaScript~~>(sample => {

<syntaxhighlight lang="javascript">(sample => {

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

Line 1,687:

=={{header|jq}}==

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

<syntaxhighlight lang=jq>add/length</syntaxhighlight>

<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

<syntaxhighlight lang="jq">def mean: if length == 0 then null

else add/length

end;</syntaxhighlight>

Line 1,700:

=={{header|Julia}}==

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

<syntaxhighlight lang=julia>julia> using Statistics; mean([1,2,3])

<syntaxhighlight lang="julia">julia> using Statistics; mean([1,2,3])

2.0

julia> mean(1:10)

Line 1,708:

=={{header|K}}==

<syntaxhighlight lang=k> mean: {(+/x)%#x}

<syntaxhighlight lang="k"> mean: {(+/x)%#x}

mean 1 2 3 5 7

3.6

Line 1,717:

Kotlin has builtin functions for some collection types.

Example:

<syntaxhighlight lang=scala>fun main(args: Array<String>) {

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

Line 1,723:

=={{header|KQL}}==

let dataset = datatable(values:real)[

1, 1.5, 3, 5, 6.5];

Line 1,741:

=={{header|Lambdatalk}}==

{def mean

{lambda {:s}

Line 1,758:

<syntaxhighlight lang=langur>val .mean = f(.x) fold(f{+}, .x) / len(.x)

<syntaxhighlight lang="langur">val .mean = f(.x) fold(f{+}, .x) / len(.x)

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

Line 1,768:

=={{header|Lasso}}==

<syntaxhighlight lang=~~Lasso~~>define average(a::array) => {

<syntaxhighlight lang="lasso">define average(a::array) => {

not #a->size ? return 0

local(x = 0.0)

Line 1,781:

=== 1-Arity ===

(defun mean (data)

(/ (lists:sum data)

Line 1,788:

Usage:

<syntaxhighlight lang=lisp>> (mean '(1 1))

<syntaxhighlight lang="lisp">> (mean '(1 1))

1.0

> (mean '(1 2))

Line 1,801:

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

<syntaxhighlight lang="lisp">(defmacro mean args

`(/ (lists:sum ,args)

,(length args)))</syntaxhighlight>

Line 1,807:

Usage:

<syntaxhighlight lang=lisp>> (mean 42)

<syntaxhighlight lang="lisp">> (mean 42)

42.0

> (mean 18 66)

Line 1,815:

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

<syntaxhighlight lang=lb>total=17

<syntaxhighlight lang="lb">total=17

dim nums(total)

for i = 1 to total

Line 1,829:

=={{header|Limbo}}==

<syntaxhighlight lang=~~Limbo~~>implement Command;

<syntaxhighlight lang="limbo">implement Command;

include "sys.m";

Line 1,855:

=={{header|Lingo}}==

<syntaxhighlight lang=~~Lingo~~>-- v can be (2D) point, (3D) vector or list of integers/floats

<syntaxhighlight lang="lingo">-- v can be (2D) point, (3D) vector or list of integers/floats

on mean (v)

case ilk(v) of

Line 1,870:

end</syntaxhighlight>

<syntaxhighlight lang=~~Lingo~~>put mean(point(1, 2.5))

<syntaxhighlight lang="lingo">put mean(point(1, 2.5))

-- 1.7500

put mean(vector(1.2, 4.7, 5.6))

Line 1,879:

=={{header|LiveCode}}==

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

<syntaxhighlight lang=~~LiveCode~~>average(1,2,3,4,5) -- 3

<syntaxhighlight lang="livecode">average(1,2,3,4,5) -- 3

average(empty) -- 0</syntaxhighlight>

=={{header|Logo}}==

<syntaxhighlight lang=logo>to average :l

<syntaxhighlight lang="logo">to average :l

if empty? :l [output 0]

output quotient apply "sum :l count :l

Line 1,891:

=={{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,911:

</syntaxhighlight>

Sample output:

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

Mean = 5.5

Line 1,918:

=={{header|LSL}}==

<syntaxhighlight lang=~~LSL~~>integer MAX_ELEMENTS = 10;

<syntaxhighlight lang="lsl">integer MAX_ELEMENTS = 10;

integer MAX_VALUE = 100;

default {

Line 1,956:

=={{header|Lua}}==

<syntaxhighlight lang=lua>function mean (numlist)

<syntaxhighlight lang="lua">function mean (numlist)

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

num = 0

Line 1,967:

=={{header|Lucid}}==

<syntaxhighlight lang=lucid>avg(x)

<syntaxhighlight lang="lucid">avg(x)

where

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

Line 1,980:

directly, but it is a little bit clearer to keep them separated.

<syntaxhighlight lang=m4>define(`extractdec', `ifelse(eval(`$1%100 < 10'),1,`0',`')eval($1%100)')dnl

<syntaxhighlight lang="m4">define(`extractdec', `ifelse(eval(`$1%100 < 10'),1,`0',`')eval($1%100)')dnl

define(`fmean', `eval(`($2/$1)/100').extractdec(eval(`$2/$1'))')dnl

define(`mean', `rmean(`$#', $@)')dnl

define(`rmean', `ifelse(`$3', `', `fmean($1,$2)',dnl

`rmean($1, eval($2+$3), shift(shift(shift($@))))')')dnl</syntaxhighlight>

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

Line 1,996:

</syntaxhighlight>

For example:

> mean( { 1/2, 2/3, 3/4, 4/5, 5/6 } ); # set

71

Line 2,020:

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

<syntaxhighlight lang=~~Maple~~>mean := () -> Normalizer( `+`( args ) / nargs ):</syntaxhighlight>

<syntaxhighlight lang="maple">mean := () -> Normalizer( `+`( args ) / nargs ):</syntaxhighlight>

This can be called as in the following examples.

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

3

Line 2,035:

</syntaxhighlight>

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

<syntaxhighlight lang=~~Maple~~>mean := ( s :: seq(algebraic) ) -> Normalizer( `+`( args ) / nargs ):</syntaxhighlight>

<syntaxhighlight lang="maple">mean := ( s :: seq(algebraic) ) -> Normalizer( `+`( args ) / nargs ):</syntaxhighlight>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Modify the built-in Mean function to give 0 for empty vectors (lists in Mathematica):

<syntaxhighlight lang=mathematica>Unprotect[Mean];

<syntaxhighlight lang="mathematica">Unprotect[Mean];

Mean[{}] := 0</syntaxhighlight>

Examples:

<syntaxhighlight lang=mathematica>Mean[{3,4,5}]

<syntaxhighlight lang="mathematica">Mean[{3,4,5}]

Mean[{3.2,4.5,5.9}]

Mean[{-4, 1.233}]

Line 2,049:

Mean[{a,c,Pi,-3,a}]</syntaxhighlight>

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

<syntaxhighlight lang=mathematica>4

<syntaxhighlight lang="mathematica">4

4.53333

-1.3835

Line 2,066:

To make it more interesting I find the Arithmectic Mean of more than a million Integers.

<lang>

/*Arithmetic Mean of a large number of Integers

- or - solve a very large constraint matrix

Line 2,095:

When run this produces:

<lang>

GLPSOL: GLPK LP/MIP Solver, v4.47

Parameter(s) specified in the command line:

Line 2,121:

=={{header|MATLAB}}==

<syntaxhighlight lang=~~Matlab~~>function meanValue = findmean(setOfValues)

<syntaxhighlight lang="matlab">function meanValue = findmean(setOfValues)

meanValue = mean(setOfValues);

end</syntaxhighlight>

=={{header|Maxima}}==

<syntaxhighlight lang=maxima>load("descriptive");

<syntaxhighlight lang="maxima">load("descriptive");

mean([2, 7, 11, 17]);</syntaxhighlight>

=={{header|MAXScript}}==

<syntaxhighlight lang=maxscript>fn mean data =

<syntaxhighlight lang="maxscript">fn mean data =

(

total = 0

Line 2,143:

=={{header|Mercury}}==

<syntaxhighlight lang=mercury>:- module arithmetic_mean.

<syntaxhighlight lang="mercury">:- module arithmetic_mean.

:- interface.

Line 2,167:

mean function is called with an empty list.

<syntaxhighlight lang=mercury>:- func mean(list(float)::in(non_empty_list)) = (float::out).

<syntaxhighlight lang="mercury">:- func mean(list(float)::in(non_empty_list)) = (float::out).

mean(Ns) = foldl((+), Ns, 0.0) / float(length(Ns)).</syntaxhighlight>

Line 2,174:

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

<syntaxhighlight lang=min>(((0 (+) reduce) (size /)) cleave) :mean

<syntaxhighlight lang="min">(((0 (+) reduce) (size /)) cleave) :mean

(2 3 5) mean print</syntaxhighlight>

Line 2,183:

=={{header|MiniScript}}==

<syntaxhighlight lang=~~MiniScript~~>arr = [ 1, 3, 7, 8, 9, 1 ]

<syntaxhighlight lang="miniscript">arr = [ 1, 3, 7, 8, 9, 1 ]

avg = function(arr)

Line 2,196:

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

<lang>0 П0 П1 С/П ИП0 ИП1 * + ИП1 1

<syntaxhighlight lang="text">0 П0 П1 С/П ИП0 ИП1 * + ИП1 1

+ П1 / П0 БП 03</syntaxhighlight>

Line 2,204:

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

<syntaxhighlight lang=modula2>PROCEDURE Avg;

<syntaxhighlight lang="modula2">PROCEDURE Avg;

VAR avg : REAL;

Line 2,215:

END Avg;</syntaxhighlight>

OR

<syntaxhighlight lang=modula2>PROCEDURE Average (Data : ARRAY OF REAL; Samples : CARDINAL) : REAL;

<syntaxhighlight lang="modula2">PROCEDURE Average (Data : ARRAY OF REAL; Samples : CARDINAL) : REAL;

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

Line 2,231:

=={{header|MUMPS}}==

<syntaxhighlight lang=~~MUMPS~~>MEAN(X)

<syntaxhighlight lang="mumps">MEAN(X)

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

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

Line 2,250:

=={{header|Nanoquery}}==

<syntaxhighlight lang=~~Nanoquery~~>def sum(lst)

<syntaxhighlight lang="nanoquery">def sum(lst)

sum = 0

for n in lst

Line 2,263:

=={{header|Nemerle}}==

<syntaxhighlight lang=~~Nemerle~~>using System;

<syntaxhighlight lang="nemerle">using System;

using System.Console;

using Nemerle.Collections;

Line 2,282:

=={{header|NetRexx}}==

<syntaxhighlight lang=~~NetRexx~~>/* NetRexx */

<syntaxhighlight lang="netrexx">/* NetRexx */

options replace format comments java crossref symbols nobinary

Line 2,357:

=={{header|NewLISP}}==

<syntaxhighlight lang=~~NewLISP~~>(define (Mean Lst)

<syntaxhighlight lang="newlisp">(define (Mean Lst)

(if (empty? Lst)

0

Line 2,367:

=={{header|Nial}}==

in the standard way, mean is

<syntaxhighlight lang=nial>mean is / [sum, tally]

<syntaxhighlight lang="nial">mean is / [sum, tally]

mean 6 2 4

Line 2,373:

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

<syntaxhighlight lang=nial>dtally is recur [ empty rest, 1 first, 1 first, plus, rest ]

<syntaxhighlight lang="nial">dtally is recur [ empty rest, 1 first, 1 first, plus, rest ]

mean is / [sum, dtally]

Line 2,381:

=={{header|Nim}}==

<syntaxhighlight lang=nim>import strutils

<syntaxhighlight lang="nim">import strutils

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

Line 2,401:

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

Line 2,413:

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

Oxford Oberon-2

MODULE AvgMean;

IMPORT Out;

Line 2,450:

=={{header|Objeck}}==

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

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

Line 2,459:

These functions return a float:

<syntaxhighlight lang=ocaml>let mean_floats = function

<syntaxhighlight lang="ocaml">let mean_floats = function

| [] -> 0.

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

Line 2,475:

would rather be handled by an exception.

<syntaxhighlight lang=ocaml>let mean_floats xs =

<syntaxhighlight lang="ocaml">let mean_floats xs =

if xs = [] then

invalid_arg "empty list"

Line 2,504:

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:

<syntaxhighlight lang=octave>function m = omean(l)

<syntaxhighlight lang="octave">function m = omean(l)

if ( numel(l) == 0 )

m = 0;

Line 2,517:

If the data contains missing value, encoded as non-a-number:

<syntaxhighlight lang=octave>function m = omean(l)

<syntaxhighlight lang="octave">function m = omean(l)

n = sum(~isnan(l));

l(isnan(l))=0;

Line 2,526:

=={{header|Oforth}}==

<syntaxhighlight lang=~~Oforth~~>: avg ( x -- avg )

<syntaxhighlight lang="oforth">: avg ( x -- avg )

x sum

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

Line 2,540:

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

Line 2,580:

=={{header|Oz}}==

A version working on floats:

<syntaxhighlight lang=oz>declare

<syntaxhighlight lang="oz">declare

fun {Mean Xs}

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

Line 2,588:

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

<syntaxhighlight lang=parigp>avg(v)={

<syntaxhighlight lang="parigp">avg(v)={

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

};</syntaxhighlight>

=={{header|Pascal}}==

<syntaxhighlight lang=pascal>Program Mean;

<syntaxhighlight lang="pascal">Program Mean;

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

Line 2,633:

Alternative version using the Math unit:

<syntaxhighlight lang=pascal>Program DoMean;

<syntaxhighlight lang="pascal">Program DoMean;

uses math;

const

Line 2,653:

=={{header|Perl}}==

<syntaxhighlight lang=perl>sub avg {

<syntaxhighlight lang="perl">sub avg {

@_ or return 0;

my $sum = 0;

Line 2,663:

=={{header|Phix}}==

with javascript_semantics

function mean(sequence s)

Line 2,674:

=={{header|Phixmonti}}==

<syntaxhighlight lang=~~Phixmonti~~>1 2 5 -5 -9.5 3.14159 stklen tolist

<syntaxhighlight lang="phixmonti">1 2 5 -5 -9.5 3.14159 stklen tolist

len swap sum swap / print</syntaxhighlight>

=={{header|PHP}}==

<syntaxhighlight lang=php>$nums = array(3, 1, 4, 1, 5, 9);

<syntaxhighlight lang="php">$nums = array(3, 1, 4, 1, 5, 9);

if ($nums)

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

Line 2,685:

=={{header|PicoLisp}}==

<syntaxhighlight lang=~~PicoLisp~~>(de mean (Lst)

<syntaxhighlight lang="picolisp">(de mean (Lst)

(if (atom Lst)

0

Line 2,694:

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

<syntaxhighlight lang=pli>arithmetic_mean = sum(A)/dimension(A,1);</syntaxhighlight>

<syntaxhighlight lang="pli">arithmetic_mean = sum(A)/dimension(A,1);</syntaxhighlight>

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

<syntaxhighlight lang=plainenglish>To run:

<syntaxhighlight lang="plainenglish">To run:

Start up.

Demonstrate finding the arithmetic mean.

Line 2,755:

=={{header|Pop11}}==

<syntaxhighlight lang=pop11>define mean(v);

<syntaxhighlight lang="pop11">define mean(v);

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

if n = 0 then

Line 2,768:

=={{header|PostScript}}==

<lang>

/findmean{

/x exch def

Line 2,788:

/avg {

dup length

Line 2,801:

=={{header|PowerShell}}==

The hard way by calculating a sum and dividing:

<syntaxhighlight lang=powershell>function mean ($x) {

<syntaxhighlight lang="powershell">function mean ($x) {

if ($x.Count -eq 0) {

return 0

Line 2,813:

}</syntaxhighlight>

or, shorter, by using the <code>Measure-Object</code> cmdlet which already knows how to compute an average:

<syntaxhighlight lang=powershell>function mean ($x) {

<syntaxhighlight lang="powershell">function mean ($x) {

if ($x.Count -eq 0) {

return 0

Line 2,822:

=={{header|Processing}}==

<syntaxhighlight lang=processing>float mean(float[] arr) {

<syntaxhighlight lang="processing">float mean(float[] arr) {

float out = 0;

for (float n : arr) {

Line 2,834:

mean(List, Mean) :-

length(List, Length),

Line 2,842:

=={{header|PureBasic}}==

<syntaxhighlight lang=~~PureBasic~~>Procedure.d mean(List number())

<syntaxhighlight lang="purebasic">Procedure.d mean(List number())

Protected sum=0

Line 2,855:

{{works with|Python|3.0}}. {{works with|Python|2.6}}

Uses [http://docs.python.org/3.3/library/math.html?highlight=fsum#math.fsum fsum] which tracks multiple partial sums to avoid losing precision

<syntaxhighlight lang=python>from math import fsum

<syntaxhighlight lang="python">from math import fsum

def average(x):

return fsum(x)/float(len(x)) if x else 0

Line 2,862:

<syntaxhighlight lang=python>2.3

<syntaxhighlight lang="python">2.3

2.3</syntaxhighlight>

<syntaxhighlight lang=python>def average(x):

<syntaxhighlight lang="python">def average(x):

return sum(x)/float(len(x)) if x else 0

print (average([0,0,3,1,4,1,5,9,0,0]))

Line 2,874:

(Notice how the second call gave the wrong result)

<syntaxhighlight lang=python>2.3

<syntaxhighlight lang="python">2.3

1e-21</syntaxhighlight>

<syntaxhighlight lang=python>def avg(data):

<syntaxhighlight lang="python">def avg(data):

if len(data)==0:

return 0

Line 2,887:

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

<syntaxhighlight lang="python">>>> from statistics import mean

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

2.3

Line 2,904:

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

<syntaxhighlight lang="q">mean:{(sum x)%count x}</syntaxhighlight>

=={{header|Quackery}}==

Line 2,910:

Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.

<syntaxhighlight lang=~~Quackery~~> [ $ 'bigrat.qky' loadfile ] now!

<syntaxhighlight lang="quackery"> [ $ 'bigrat.qky' loadfile ] now!

[ [] swap times

Line 2,990:

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:

<syntaxhighlight lang=rsplus>omean <- function(v) {

<syntaxhighlight lang="rsplus">omean <- function(v) {

m <- mean(v)

ifelse(is.na(m), 0, m)

Line 2,999:

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 3,012:

<syntaxhighlight lang=~~perl6~~>multi mean([]){ Failure.new('mean on empty list is not defined') }; # Failure-objects are lazy exceptions

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

<syntaxhighlight lang="rapira">fun mean(arr)

sum := 0

for N from 1 to #arr do

Line 3,025:

=={{header|REBOL}}==

<syntaxhighlight lang=~~REBOL~~>rebol [

<syntaxhighlight lang="rebol">rebol [

Title: "Arithmetic Mean (Average)"

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

Line 3,054:

=={{header|Red}}==

Red comes with the <code>average</code> function.

<syntaxhighlight lang=red>Red ["Arithmetic mean"]

<syntaxhighlight lang="red">Red ["Arithmetic mean"]

print average []

Line 3,065:

The source code for <code>average</code>:

<syntaxhighlight lang=red>average: func [

<syntaxhighlight lang="red">average: func [

"Returns the average of all values in a block"

block [block! vector! paren! hash!]

Line 3,075:

=={{header|ReScript}}==

<syntaxhighlight lang=~~ReScript~~>let arr = [3, 8, 4, 1, 5, 12]

<syntaxhighlight lang="rescript">let arr = [3, 8, 4, 1, 5, 12]

let num = Js.Array.length(arr)

Line 3,093:

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*/

<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

Line 3,154:

=={{header|Ring}}==

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

sum = 0

Line 3,170:

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

<syntaxhighlight lang=rpl/2>1 2 3 5 7

<syntaxhighlight lang="rpl/2">1 2 3 5 7

AMEAN

<< DEPTH DUP 'N' STO ->LIST ΣLIST N / >>

Line 3,176:

=={{header|Ruby}}==

<syntaxhighlight lang=ruby>def mean(nums)

<syntaxhighlight lang="ruby">def mean(nums)

nums.sum(0.0) / nums.size

end

Line 3,197:

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

<syntaxhighlight lang=runbasic>print "Gimme the number in the array:";input numArray

<syntaxhighlight lang="runbasic">print "Gimme the number in the array:";input numArray

dim value(numArray)

for i = 1 to numArray

Line 3,210:

=={{header|Rust}}==

<syntaxhighlight lang=rust>fn sum(arr: &[f64]) -> f64 {

<syntaxhighlight lang="rust">fn sum(arr: &[f64]) -> f64 {

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

}

Line 3,231:

=={{header|Sather}}==

Built to work with VEC, ("geometric" vectors), whose elements must be floats. A 0-dimension vector yields "nan".

<syntaxhighlight lang=sather>class VECOPS is

<syntaxhighlight lang="sather">class VECOPS is

mean(v:VEC):FLT is

m ::= 0.0;

Line 3,249:

Using Scala 2.7, this has to be defined for each numeric type:

<syntaxhighlight lang=scala>def mean(s: Seq[Int]) = s.foldLeft(0)(_+_) / s.size</syntaxhighlight>

<syntaxhighlight lang="scala">def mean(s: Seq[Int]) = s.foldLeft(0)(_+_) / s.size</syntaxhighlight>

However, Scala 2.8 gives much more flexibility, but you still have to opt

between integral types and fractional types. For example:

<syntaxhighlight lang=scala>def mean[T](s: Seq[T])(implicit n: Integral[T]) = {

<syntaxhighlight lang="scala">def mean[T](s: Seq[T])(implicit n: Integral[T]) = {

import n._

s.foldLeft(zero)(_+_) / fromInt(s.size)

Line 3,267:

Alas, Scala 2.8 also simplifies the task in another way:

<syntaxhighlight lang=scala>def mean[T](s: Seq[T])(implicit n: Fractional[T]) = n.div(s.sum, n.fromInt(s.size))</syntaxhighlight>

<syntaxhighlight lang="scala">def mean[T](s: Seq[T])(implicit n: Fractional[T]) = n.div(s.sum, n.fromInt(s.size))</syntaxhighlight>

Here we show a function that supports fractional types. Instead of importing the definitions

Line 3,275:

=={{header|Scheme}}==

<syntaxhighlight lang=scheme>(define (mean l)

<syntaxhighlight lang="scheme">(define (mean l)

(if (null? l)

0

Line 3,284:

=={{header|Seed7}}==

<syntaxhighlight lang=seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

include "float.s7i";

Line 3,311:

=={{header|SenseTalk}}==

SenseTalk has a built-in average function.

<syntaxhighlight lang=sensetalk>put the average of [12,92,-17,66,128]

<syntaxhighlight lang="sensetalk">put the average of [12,92,-17,66,128]

put average(empty)

Line 3,322:

=={{header|Sidef}}==

<syntaxhighlight lang=ruby>func avg(Array list) {

<syntaxhighlight lang="ruby">func avg(Array list) {

list.len > 0 || return 0;

list.sum / list.len;

Line 3,341:

=={{header|Slate}}==

<syntaxhighlight lang=slate>[|:list| (list reduce: #+ `er ifEmpty: [0]) / (list isEmpty ifTrue: [1] ifFalse: [list size])] applyWith: #(3 1 4 1 5 9).

<syntaxhighlight lang="slate">[|:list| (list reduce: #+ `er ifEmpty: [0]) / (list isEmpty ifTrue: [1] ifFalse: [list size])] applyWith: #(3 1 4 1 5 9).

[|:list| (list reduce: #+ `er ifEmpty: [0]) / (list isEmpty ifTrue: [1] ifFalse: [list size])] applyWith: {}.</syntaxhighlight>

=={{header|Smalltalk}}==

| numbers |

Line 3,356:

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

Line 3,365:

| numbers |

Line 3,372:

</syntaxhighlight>

or

| numbers |

Line 3,385:

<syntaxhighlight lang=~~SNOBOL4~~> define('avg(a)i,sum') :(avg_end)

<syntaxhighlight lang="snobol4"> define('avg(a)i,sum') :(avg_end)

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

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

Line 3,406:

=={{header|SQL}}==

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

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

Line 3,414:

</syntaxhighlight>

...or...

<syntaxhighlight lang=~~SQL~~>select avg("datapoint") from "numbers";</syntaxhighlight>

<syntaxhighlight lang="sql">select avg("datapoint") from "numbers";</syntaxhighlight>

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

These functions return a real:

<syntaxhighlight lang=sml>fun mean_reals [] = 0.0

<syntaxhighlight lang="sml">fun mean_reals [] = 0.0

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

Line 3,432:

would rather be handled by an exception.

<syntaxhighlight lang=sml>fun mean_reals [] = raise Empty

<syntaxhighlight lang="sml">fun mean_reals [] = raise Empty

| mean_reals xs = let

val (total, length) =

Line 3,456:

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

<lang>clear all

<syntaxhighlight lang="text">clear all

input str20 country population

Belgium 11311.1

Line 3,489:

=== Mean in Mata ===

<syntaxhighlight lang=stata>mata

<syntaxhighlight lang="stata">mata

a=11311.1\7153.8\10553.8\5707.3\

82175.7\1315.9\4724.7\10783.7

Line 3,497:

=={{header|Swift}}==

<syntaxhighlight lang=swift>func meanDoubles(s: [Double]) -> Double {

<syntaxhighlight lang="swift">func meanDoubles(s: [Double]) -> Double {

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

}

Line 3,505:

=={{header|Tcl}}==

<syntaxhighlight lang=tcl>package require Tcl 8.5

<syntaxhighlight lang="tcl">package require Tcl 8.5

proc mean args {

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

Line 3,513:

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

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

<syntaxhighlight lang=ti89b>Define rcmean(nums) = when(dim(nums) = 0, 0, mean(nums))</syntaxhighlight>

<syntaxhighlight lang="ti89b">Define rcmean(nums) = when(dim(nums) = 0, 0, mean(nums))</syntaxhighlight>

=={{header|Trith}}==

<syntaxhighlight lang=trith>: mean dup empty? [drop 0] [dup [+] foldl1 swap length /] branch ;

<syntaxhighlight lang="trith">: mean dup empty? [drop 0] [dup [+] foldl1 swap length /] branch ;

[3 1 4 1 5 9] mean</syntaxhighlight>

=={{header|TypeScript}}==

function mean(numbersArr)

{

Line 3,545:

=={{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 lang="bash1">echo "`cat f | paste -sd+ | bc -l` / `cat f | wc -l`" | bc -l

</syntaxhighlight>

<syntaxhighlight lang=bash1>cat f

<syntaxhighlight lang="bash1">cat f

1

2

Line 3,573:

2) This example uses <tt>expr</tt>, so it only works with integers. It checks that each string in the list is an integer.

<syntaxhighlight lang=bash>mean() {

<syntaxhighlight lang="bash">mean() {

if expr $# >/dev/null; then

(count=0

Line 3,603:

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

<syntaxhighlight lang=bash>term() {

<syntaxhighlight lang="bash">term() {

b=$1;res=$2

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

Line 3,627:

=={{header|Ursa}}==

<syntaxhighlight lang=ursa>#

<syntaxhighlight lang="ursa">#

# arithmetic mean

#

Line 3,642:

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.

<syntaxhighlight lang=~~Ursala~~>#import nat

<syntaxhighlight lang="ursala">#import nat

#import flo

Line 3,654:

=={{header|V}}==

<syntaxhighlight lang=v>[mean

<syntaxhighlight lang="v">[mean

[sum 0 [+] fold].

dup sum

Line 3,662:

=={{header|Vala}}==

Using array to hold the numbers of the list:

double arithmetic(double[] list){

double mean;

Line 3,697:

=={{header|VBA}}==

<syntaxhighlight lang=vb>Private Function mean(v() As Double, ByVal leng As Integer) As Variant

<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

Line 3,733:

=={{header|VBScript}}==

Function mean(arr)

size = UBound(arr) + 1

Line 3,752:

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

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

<syntaxhighlight lang=vedit>#1 = 0 // Sum

<syntaxhighlight lang="vedit">#1 = 0 // Sum

#2 = 0 // Count

BOF

Line 3,765:

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

Throws an exception if the list is empty.

<syntaxhighlight lang=vim>function Mean(lst)

<syntaxhighlight lang="vim">function Mean(lst)

if empty(a:lst)

throw "Empty"

Line 3,777:

=={{header|Vlang}}==

<syntaxhighlight lang=vlang>import math

<syntaxhighlight lang="vlang">import math

import arrays

Line 3,819:

=={{header|Wart}}==

<syntaxhighlight lang=python>def (mean l)

<syntaxhighlight lang="python">def (mean l)

sum.l / len.l</syntaxhighlight>

Line 3,827:

=={{header|WDTE}}==

<syntaxhighlight lang=~~WDTE~~>let s => import 'stream';

<syntaxhighlight lang="wdte">let s => import 'stream';

let a => import 'arrays';

Line 3,838:

Usage:

<syntaxhighlight lang=~~WDTE~~>mean [1; 2; 3] -- io.writeln io.stdout;</syntaxhighlight>

<syntaxhighlight lang="wdte">mean [1; 2; 3] -- io.writeln io.stdout;</syntaxhighlight>

Output:

Line 3,844:

=={{header|Wortel}}==

<syntaxhighlight lang=wortel>@let {

<syntaxhighlight lang="wortel">@let {

; using a fork (sum divided-by length)

mean1 @(@sum / #)

Line 3,860:

=={{header|Wren}}==

<syntaxhighlight lang=ecmascript>class Arithmetic {

<syntaxhighlight lang="ecmascript">class Arithmetic {

static mean(arr) {

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

Line 3,870:

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

<syntaxhighlight lang="lisp">(defun mean (v)

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

nil

Line 3,877:

=={{header|XPL0}}==

<syntaxhighlight lang=~~XPL0~~>code CrLf=9;

<syntaxhighlight lang="xpl0">code CrLf=9;

code real RlOut=48;

Line 3,904:

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>

<syntaxhighlight lang="xpath">sum($values) div count($values)</syntaxhighlight>

===Runnable example===

<xsl:output method="text"/>

Line 3,919:

Sample input:

Line 3,929:

=={{header|Yorick}}==

<syntaxhighlight lang=yorick>func mean(x) {

<syntaxhighlight lang="yorick">func mean(x) {

if(is_void(x)) return 0;

return x(*)(avg);

Line 3,936:

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

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

<syntaxhighlight lang=zkl>fcn meanV(z){ z.reduce('+,0.0)/z.len() }

<syntaxhighlight lang="zkl">fcn meanV(z){ z.reduce('+,0.0)/z.len() }

meanV(T(3,1,4,1,5,9)); // --> 3.83333</syntaxhighlight>

=={{header|Zoea}}==

program: average

case: 1

Line 3,955:

=={{header|zonnon}}==

module Averages;

type