Averages/Pythagorean means: Difference between revisions

{{task}}

 

 

* The most common of the three means, the [[Averages/Arithmetic mean|arithmetic mean]], is the sum of the list divided by its length:

* The [[wp:Geometric mean|geometric mean]] is the <math>n</math>th root of the product of the list:

* The [[wp:Harmonic mean|harmonic mean]] is <math>n</math> divided by the sum of the reciprocal of each item in the list:

 

 

=={{header|ActionScript}}==

{

var sum:Number = 0;

trace("Arithmetic: ", arithmeticMean(list));

trace("Geometric: ", geometricMean(list));

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

{{trans|C}}

{{wont work with|ALGOL 68|Standard - argc and argv implementation dependent}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - argc and argv implementation dependent}}

INT count:=0;

LONG REAL f, sum:=0, prod:=1, resum:=0;

 

 

FILE fbuf; STRING sbuf; associate(fbuf,sbuf);

 

FOR i TO argc DO

ELSE

rewind(fbuf); sbuf := argv(i); get(fbuf,f);

printf(($"c: "f(real)l"s: "f(real)l"p: "f(real)l"r: "f(real)l$,count,sum,prod,resum));

printf(($"Arithmetic mean = "f(real)l$,sum/count));

printf(($"Harmonic mean = "f(real)l$,count/resum))

<pre>

c: 10.0000

r: 2.9290

Arithmetic mean = 5.5000

Harmonic mean = 3.4142

</pre>

 

=={{header|C}}==

#include <stdlib.h> // atoi()

#include <math.h> // pow()

 

return 0;

}

 

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

(funcall final-op (reduce reduce-op nums)))

 

(format t "a-mean ~a~%" a-mean)

(format t "g-mean ~a~%" g-mean)

 

 

=={{header|Factor}}==

[ sum ] [ length ] bi / ;

 

 

: h-mean ( seq -- mean )

 

( scratchpad ) 10 [1,b] [ a-mean ] [ g-mean ] [ h-mean ] tri

"%f >= %f >= %f\n" printf

5.500000 >= 4.528729 >= 3.414172

 

=={{header|Forth}}==

0e

tuck floats bounds do

test 10 fhmean fdup f.

( A G G H )

 

=={{header|Fortran}}==

{{works with|Fortran|90}}

 

real :: a(10) = (/ (i, i=1,10) /)

end if

 

 

=={{header|Haskell}}==

The [[wp:Generalized mean|general function]] given here yields an arithmetic mean when its first argument is <code>1</code>, a geometric mean when its first argument is <code>0</code>, and a harmonic mean when its first argument is <code>-1</code>.

 

import Control.Monad (zipWithM_)

 

mean p xs = (1 / genericLength xs * sum (map (** p) xs)) ** (1/p)

 

 

=={{header|J}}==

'''Solution:'''

gmean=: # %: */

 

'''Example Usage:'''

5.5 4.528729 3.414172

 

=={{header|JavaScript}}==

 

 

}

 

 

 

=={{header|Lua}}==

function pymean(t, f, finv) return finv(fsum(f, unpack(t)) / #t) end

nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

h = pymean(nums, function(n) return 1/n end, function(n) return 1/n end)

print(a, g, h)

 

 

=={{header|MUMPS}}==

 

For ii=1:1:n set x(ii)=ii

;

Pythagorean means for 1..10:

 

 

=={{header|OCaml}}==

The three means in one function

 

let n = Array.length v

and a = ref 0.0

let nn = float_of_int n in

(!a /. nn, !b ** (1.0/.nn), nn /. !c)

 

 

Another implementation using <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html#VALfold_left Array.fold_left]</code> instead of a '''for''' loop:

 

let (a, b, c) =

Array.fold_left

let n = float_of_int (Array.length v) in

(a /. n, b ** (1./.n), n /. c)

 

=={{header|Oz}}==

%% helpers

fun {Sum Xs} {FoldL Xs Number.'+' 0.0} end

{Show [A G H]}

A >= G = true

 

=={{header|Perl}}==

{

my $a = 0;

 

print "A=$a\nG=$g\nH=$h\n";

 

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

declare n fixed binary,

(Average, Geometric, Harmonic) float;

if Average < Geometric then put skip list ('Error');

if Geometric < Harmonic then put skip list ('Error');

 

=={{header|PureBasic}}==

For a = 1 To 10

mean + a

Debug ArithmeticMean()

Debug GeometricMean()

 

=={{header|Python}}==

from functools import reduce

 

def amean(num):

 

def gmean(num):

 

def hmean(num):

 

a, g, h = amean(numbers), gmean(numbers), hmean(numbers)

print(a, g, h)

 

Output:

 

 

=={{header|Ruby}}==

{{works with|Ruby|1.9+}}

def arithmetic_mean

end

def geometric_mean

inject(:*) ** (1.0 / length)

end

def harmonic_mean

end

end

p h = (1..10).harmonic_mean

# is h < g < a ??

 

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

(/ (apply + l) (length l)))

 

(newline)

(display (>= a g h))

=={{header|Tcl}}==

set sum 0.0

foreach value $list { set sum [expr {$sum + $value}] }

puts "A10=$A10, G10=$G10, H10=$H10"

if {$A10 >= $G10} { puts "A10 >= G10" }

 

<pre>

A10=5.5, G10=4.528728688116765, H10=3.414171521474055

</pre>