Averages/Pythagorean means: Difference between revisions

From Rosetta Code
Content added Content deleted
Line 162: Line 162:
harmonic x
harmonic x
3.414171521</lang>
3.414171521</lang>


=={{header|AppleScript}}==

{{trans|JavaScript}}
<lang AppleScript>on run
set {A, G, H} to ¬
map(my test, {arithmetic_mean, geometric_mean, harmonic_mean})
return {values:{A, G, H}, inequalities:{|A >= G|:A ≥ G}, |G >= H|:G ≥ H}
end run

on test(f)
mReturn(f)'s lambda({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
end test

-- arithmetic_mean :: [Number] -> Number
on arithmetic_mean(ns)
foldl(my sum, 0, ns) / (length of ns)
end arithmetic_mean

-- geometric_mean :: [Number] -> Number
on geometric_mean(ns)
foldl(my product, 1, ns) ^ (1 / (length of ns))
end geometric_mean

-- harmonic_mean :: [Number] -> Number
on harmonic_mean(ns)
(length of ns) / (foldl(my addInverse, 0, ns))
end harmonic_mean

-- sum :: Number -> Number -> Number
on sum(accumulator, x)
accumulator + x
end sum

-- product :: Number -> Number -> Number
on product(accumulator, x)
accumulator * x
end product

-- addInverse :: Number -> Number -> Number
on addInverse(accumulator, x)
accumulator + (1 / x)
end addInverse



-- GENERIC FUNCTIONS

-- Fold left - analogous to JavaScript's Array.reduce()

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
set mf to mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to mf's lambda(v, item i of xs, i, xs)
end repeat
return v
end foldl

-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
set mf to mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to mf's lambda(item i of xs, i, xs)
end repeat
return lst
end map

-- Lift 2nd class function into 1st class wrapper
-- handler function --> first class script object
on mReturn(f)
if class of f is script then return f
script
property lambda : f
end script
end mReturn</lang>

{{Out}}
<pre>{values:{5.5, 4.528728688117, 3.414171521474},
inequalities:{|A >= G|:true}, |G >= H|:true}</pre>


=={{header|AutoHotkey}}==
=={{header|AutoHotkey}}==

Revision as of 21:38, 28 June 2016

Task
Averages/Pythagorean means
You are encouraged to solve this task according to the task description, using any language you may know.

Compute all three of the   Pythagorean means   of the set of integers   1   through   10   (inclusive).

Show that     for this set of positive integers.

  • The most common of the three means, the   arithmetic mean,   is the sum of the list divided by its length:
  • The geometric mean is the   th   root of the product of the list:
  • The   harmonic mean   is     divided by the sum of the reciprocal of each item in the list:


C.f.



ActionScript

<lang ActionScript>function arithmeticMean(v:Vector.<Number>):Number { var sum:Number = 0; for(var i: uint = 0; i < v.length; i++) sum += v[i]; return sum/v.length; } function geometricMean(v:Vector.<Number>):Number { var product:Number = 1; for(var i: uint = 0; i < v.length; i++) product *= v[i]; return Math.pow(product, 1/v.length); } function harmonicMean(v:Vector.<Number>):Number { var sum:Number = 0; for(var i: uint = 0; i < v.length; i++) sum += 1/v[i]; return v.length/sum; } var list:Vector.<Number> = Vector.<Number>([1,2,3,4,5,6,7,8,9,10]); trace("Arithmetic: ", arithmeticMean(list)); trace("Geometric: ", geometricMean(list)); trace("Harmonic: ", harmonicMean(list));</lang>

Ada

pythagorean_means.ads: <lang Ada>package Pythagorean_Means is 

  type Set is array (Positive range <>) of Float;
  function Arithmetic_Mean (Data : Set) return Float;
  function Geometric_Mean  (Data : Set) return Float;
  function Harmonic_Mean   (Data : Set) return Float;

end Pythagorean_Means;</lang>

pythagorean_means.adb: <lang Ada>with Ada.Numerics.Generic_Elementary_Functions; package body Pythagorean_Means is 

  package Math is new Ada.Numerics.Generic_Elementary_Functions (Float);
  function "**" (Left, Right : Float) return Float renames Math."**";

  function Arithmetic_Mean (Data : Set) return Float is
     Sum : Float := 0.0;
  begin
     for I in Data'Range loop
        Sum := Sum + Data (I);
     end loop;
     return Sum / Float (Data'Length);
  end Arithmetic_Mean;

  function Geometric_Mean (Data : Set) return Float is
     Product : Float := 1.0;
  begin
     for I in Data'Range loop
        Product := Product * Data (I);
     end loop;
     return Product**(1.0/Float(Data'Length));
  end Geometric_Mean;

  function Harmonic_Mean (Data : Set) return Float is
     Reciprocal_Sum : Float := 0.0;
  begin
     for I in Data'Range loop
        Reciprocal_Sum := Reciprocal_Sum + Data (I)**(-1);
     end loop;
     return Float (Data'Length) / Reciprocal_Sum;
  end Harmonic_Mean;

end Pythagorean_Means;</lang>

example main.adb: <lang Ada>with Ada.Text_IO; with Pythagorean_Means; procedure Main is 

  My_Set : Pythagorean_Means.Set := (1.0, 2.0, 3.0, 4.0,  5.0,
                                     6.0, 7.0, 8.0, 9.0, 10.0);
  Arithmetic_Mean : Float := Pythagorean_Means.Arithmetic_Mean (My_Set);
  Geometric_Mean  : Float := Pythagorean_Means.Geometric_Mean  (My_Set);
  Harmonic_Mean   : Float := Pythagorean_Means.Harmonic_Mean   (My_Set);

begin 

  Ada.Text_IO.Put_Line (Float'Image (Arithmetic_Mean) & " >= " &
                        Float'Image (Geometric_Mean)  & " >= " &
                        Float'Image (Harmonic_Mean));

end Main;</lang>

ALGOL 68

Translation of: C
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

<lang algol68>main: ( 

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

 FORMAT real = $g(0,4)$; # preferred real format #

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

 BOOL opts := TRUE;

 FOR i TO argc DO
   IF opts THEN # skip args up to the - token #
     opts := argv(i) NE "-"
   ELSE
     rewind(fbuf); sbuf := argv(i); get(fbuf,f);
     count +:= 1;
     sum +:= f;
     prod *:= f;
     resum +:= 1/f
   FI
 OD;
 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(($"Geometric mean = "f(real)l$,prod**(1/count)));
 printf(($"Harmonic mean = "f(real)l$,count/resum))

)</lang> Lunix command: 

a68g Averages_Pythagorean_means.a68 - 1 2 3 4 5 6 7 8 9 10
Output:
c: 10.0000
s: 55.0000
p: 3628800.0000
r: 2.9290
Arithmetic mean = 5.5000
Geometric mean = 4.5287
Harmonic mean = 3.4142

APL

<lang APL> 

arithmetic←{(+/⍵)÷⍴⍵}
geometric←{(×/⍵)*÷⍴⍵}
harmonic←{(⍴⍵)÷(+/÷⍵)}



x←⍳10

arithmetic x

5.5 

geometric x

4.528728688 

harmonic x

3.414171521</lang>


AppleScript

Translation of: JavaScript

<lang AppleScript>on run 

   set {A, G, H} to ¬
       map(my test, {arithmetic_mean, geometric_mean, harmonic_mean})
   
   return {values:{A, G, H}, inequalities:{|A >= G|:A ≥ G}, |G >= H|:G ≥ H}

end run

on test(f) 

   mReturn(f)'s lambda({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

end test

-- arithmetic_mean :: [Number] -> Number on arithmetic_mean(ns) 

   foldl(my sum, 0, ns) / (length of ns)

end arithmetic_mean

-- geometric_mean :: [Number] -> Number on geometric_mean(ns) 

   foldl(my product, 1, ns) ^ (1 / (length of ns))

end geometric_mean

-- harmonic_mean :: [Number] -> Number on harmonic_mean(ns) 

   (length of ns) / (foldl(my addInverse, 0, ns))

end harmonic_mean

-- sum :: Number -> Number -> Number on sum(accumulator, x) 

   accumulator + x

end sum

-- product :: Number -> Number -> Number on product(accumulator, x) 

   accumulator * x

end product

-- addInverse :: Number -> Number -> Number on addInverse(accumulator, x) 

   accumulator + (1 / x)

end addInverse


-- GENERIC FUNCTIONS

-- Fold left - analogous to JavaScript's Array.reduce()

-- foldl :: (a -> b -> a) -> a -> [b] -> a on foldl(f, startValue, xs) 

   set mf to mReturn(f)
   set v to startValue
   set lng to length of xs
   repeat with i from 1 to lng
       set v to mf's lambda(v, item i of xs, i, xs)
   end repeat
   return v

end foldl

-- map :: (a -> b) -> [a] -> [b] on map(f, xs) 

   set mf to mReturn(f)
   set lng to length of xs
   set lst to {}
   repeat with i from 1 to lng
       set end of lst to mf's lambda(item i of xs, i, xs)
   end repeat
   return lst

end map

-- Lift 2nd class function into 1st class wrapper -- handler function --> first class script object on mReturn(f) 

   if class of f is script then return f
   script
       property lambda : f
   end script

end mReturn</lang>

Output:
{values:{5.5, 4.528728688117, 3.414171521474}, 
inequalities:{|A >= G|:true}, |G >= H|:true}

AutoHotkey

<lang autohotkey>A := ArithmeticMean(1, 10) G := GeometricMean(1, 10) H := HarmonicMean(1, 10)

If G Between %H% And %A% 

   Result := "True"

Else 

   Result := "False"

MsgBox, %A%`n%G%`n%H%`n%Result%


---------------------------------------------------------------------------

ArithmeticMean(a, b) { ; of integers a through b

---------------------------------------------------------------------------
   n := b - a + 1
   Loop, %n%
       Sum += (a + A_Index - 1)
   Return, Sum / n

}


---------------------------------------------------------------------------

GeometricMean(a, b) { ; of integers a through b

---------------------------------------------------------------------------
   n := b - a + 1
   Prod := 1
   Loop, %n%
       Prod *= (a + A_Index - 1)
   Return, Prod ** (1 / n)

}


---------------------------------------------------------------------------

HarmonicMean(a, b) { ; of integers a through b

---------------------------------------------------------------------------
   n := b - a + 1
   Loop, %n%
       Sum += 1 / (a + A_Index - 1)
   Return, n / Sum

}</lang> Message box shows: 

5.500000
4.528729
3.414172
True

AWK

<lang awk>#!/usr/bin/awk -f { 

   x  = $1;   # value of 1st column
   A += x;  
   G += log(x);  
   H += 1/x;
   N++;

}

END { 

  print "Arithmethic mean: ",A/N;
  print "Geometric mean  : ",exp(G/N);
  print "Harmonic mean   : ",N/H;

}</lang>

BBC BASIC

The arithmetic and harmonic means use BBC BASIC's built-in array operations; only the geometric mean needs a loop. <lang bbcbasic> DIM a(9) 

     a() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
     PRINT "Arithmetic mean = " ; FNarithmeticmean(a())
     PRINT "Geometric mean =  " ; FNgeometricmean(a())
     PRINT "Harmonic mean =  " ; FNharmonicmean(a())
     END
     
     DEF FNarithmeticmean(a())
     = SUM(a()) / (DIM(a(),1)+1)
     
     DEF FNgeometricmean(a())
     LOCAL a, I%
     a = 1
     FOR I% = 0 TO DIM(a(),1)
       a *= a(I%)
     NEXT
     = a ^ (1/(DIM(a(),1)+1))
     
     DEF FNharmonicmean(a())
     LOCAL b()
     DIM b(DIM(a(),1))
     b() = 1/a()
     = (DIM(a(),1)+1) / SUM(b())

</lang>

Output:
Arithmetic mean = 5.5
Geometric mean =  4.52872869
Harmonic mean =  3.41417152

C

<lang c>#include <stdio.h>

  1. include <stdlib.h> // atoi()
  2. include <math.h> // pow()

int main(int argc, char* argv[]) { 

 int i, count=0;
 double f, sum=0.0, prod=1.0, resum=0.0;

 for (i=1; i<argc; ++i) {
   f = atof(argv[i]);
   count++;
   sum += f;
   prod *= f;
   resum += (1.0/f);
 }
 //printf(" c:%d\n s:%f\n p:%f\n r:%f\n",count,sum,prod,resum);
 printf("Arithmetic mean = %f\n",sum/count);
 printf("Geometric mean = %f\n",pow(prod,(1.0/count)));
 printf("Harmonic mean = %f\n",count/resum);

 return 0;

}</lang>

C++

<lang cpp>#include <vector>

  1. include <iostream>
  2. include <numeric>
  3. include <cmath>
  4. include <algorithm>

double toInverse ( int i ) { 

  return  1.0 / i  ;

}

int main( ) { 

  std::vector<int> numbers ;
  for ( int i = 1 ; i < 11 ; i++ ) 
     numbers.push_back( i ) ;
  double arithmetic_mean = std::accumulate( numbers.begin( ) , numbers.end( ) , 0 ) / 10.0 ;
  double geometric_mean =
     pow( std::accumulate( numbers.begin( ) , numbers.end( ) , 1 , std::multiplies<int>( ) ), 0.1 ) ;
  std::vector<double> inverses ;
  inverses.resize( numbers.size( ) ) ;
  std::transform( numbers.begin( ) , numbers.end( ) , inverses.begin( ) , toInverse ) ;  
  double harmonic_mean = 10 / std::accumulate( inverses.begin( ) , inverses.end( ) , 0.0 ); //initial value of accumulate must be a double!
  std::cout << "The arithmetic mean is " << arithmetic_mean << " , the geometric mean " 
     << geometric_mean << " and the harmonic mean " << harmonic_mean << " !\n" ;
  return 0 ;

}</lang>

Output:
The arithmetic mean is 5.5 , the geometric mean 4.52873 and the harmonic mean 3.41417 !

C#

The standard Linq extension method Average provides arithmetic mean. This example adds two more extension methods for the geometric and harmonic means.

Works with: C# version 3

<lang csharp>using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq;

namespace PythMean { 

   static class Program
   {
       static void Main(string[] args) {
           var nums = from n in Enumerable.Range(1, 10) select (double)n;

           var a = nums.Average();
           var g = nums.Gmean();
           var h = nums.Hmean();

           Console.WriteLine("Arithmetic mean {0}", a);
           Console.WriteLine("Geometric mean  {0}", g);
           Console.WriteLine("Harmonic mean   {0}", h);

           Debug.Assert(a >= g && g >= h);
       }

       // Geometric mean extension method.
       static double Gmean(this IEnumerable<double> n) {
           return Math.Pow(n.Aggregate((s, i) => s * i), 1.0 / n.Count());
       }

       // Harmonic mean extension method.
       static double Hmean(this IEnumerable<double> n) {
           return n.Count() / n.Sum(i => 1 / i);
       }
   }

}</lang>

Output:
Arithmetic mean 5.5
Geometric mean  4.52872868811677
Harmonic mean   3.41417152147406

CoffeeScript

<lang coffeescript>a = [ 1..10 ] arithmetic_mean = (a) -> a.reduce(((s, x) -> s + x), 0) / a.length geometic_mean = (a) -> Math.pow(a.reduce(((s, x) -> s * x), 1), (1 / a.length)) harmonic_mean = (a) -> a.length / a.reduce(((s, x) -> s + 1 / x), 0)

A = arithmetic_mean a G = geometic_mean a H = harmonic_mean a

console.log "A = ", A, " G = ", G, " H = ", H console.log "A >= G : ", A >= G, " G >= H : ", G >= H</lang>

Output:
A =  5.5  G =  4.528728688116765  H =  3.414171521474055
A >= G :  true  G >= H :  true

Common Lisp

<lang lisp>(defun generic-mean (nums reduce-op final-op) 

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

(defun a-mean (nums) 

 (generic-mean nums #'+ (lambda (x) (/ x (length nums)))))

(defun g-mean (nums) 

 (generic-mean nums #'* (lambda (x) (expt x (/ 1 (length nums))))))

(defun h-mean (nums) 

 (generic-mean nums 
               (lambda (x y) (+ x
                                (/ 1 y)))
               (lambda (x) (/ (length nums) x))))

(let ((numbers (loop for i from 1 to 10 collect i))) 

 (let ((a-mean (a-mean numbers))
       (g-mean (g-mean numbers))
       (h-mean (h-mean numbers)))
   (assert (> a-mean g-mean h-mean))
   (format t "a-mean ~a~%" a-mean)
   (format t "g-mean ~a~%" g-mean)
   (format t "h-mean ~a~%" h-mean)))</lang>

Clojure

<lang Clojure>(use '[clojure.contrib.math :only (expt)])

(defn a-mean [coll] 

 (/ (apply + coll) (count coll)))

(defn g-mean [coll] 

 (expt (apply * coll) (/ (count coll))))

(defn h-mean [coll] 

 (/ (count coll) (apply + (map / coll))))

(let [numbers (range 1 11) 

     a (a-mean numbers) g (g-mean numbers) h (h-mean numbers)]
 (println a ">=" g ">=" h)
 (>= a g h))</lang>

D

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

auto aMean(T)(T data) pure nothrow @nogc { 

   return data.sum / data.length;

}

auto gMean(T)(T data) pure /*@nogc*/ { 

   return data.reduce!q{a * b} ^^ (1.0 / data.length);

}

auto hMean(T)(T data) pure /*@nogc*/ { 

   return data.length / data.reduce!q{ 1.0 / a + b };

}

void main() { 

   immutable m = [adjoin!(hMean, gMean, aMean)(iota(1.0L, 11.0L))[]];
   writefln("%(%.19f %)", m);
   assert(m.isSorted);

}</lang>

Output:
0.9891573712076470036 4.5287286881167647619 5.5000000000000000000

Delphi

<lang Delphi>program AveragesPythagoreanMeans;

{$APPTYPE CONSOLE}

uses Types, Math;

function ArithmeticMean(aArray: TDoubleDynArray): Double; var 

 lValue: Double;

begin 

 Result := 0;
 for lValue in aArray do
   Result := Result + lValue;
 if Result > 0 then
   Result := Result / Length(aArray);

end;

function GeometricMean(aArray: TDoubleDynArray): Double; var 

 lValue: Double;

begin 

 Result := 1;
 for lValue in aArray do
   Result := Result * lValue;
 Result := Power(Result, 1 / Length(aArray));

end;

function HarmonicMean(aArray: TDoubleDynArray): Double; var 

 lValue: Double;

begin 

 Result := 0;
 for lValue in aArray do
   Result := Result + 1 / lValue;
 Result := Length(aArray) / Result;

end;

var 

 lSourceArray: TDoubleDynArray;
 AMean, GMean, HMean: Double;

begin 

 lSourceArray := TDoubleDynArray.Create(1,2,3,4,5,6,7,8,9,10);
 AMean := ArithmeticMean(lSourceArray));
 GMean := GeometricMean(lSourceArray));
 HMean := HarmonicMean(lSourceArray));
 if (AMean >= GMean) and (GMean >= HMean) then
   Writeln(AMean, " ≥ ", GMean, " ≥ ", HMean)
 else
   writeln("Error!");

end.</lang>

E

Given that we're defining all three together, it makes sense to express their regularities:

<lang e>def makeMean(base, include, finish) { 

   return def mean(numbers) {
       var count := 0
       var acc := base
       for x in numbers {
           acc := include(acc, x)
           count += 1
       }
       return finish(acc, count)
   }

}

def A := makeMean(0, fn b,x { b+x }, fn acc,n { acc / n }) def G := makeMean(1, fn b,x { b*x }, fn acc,n { acc ** (1/n) }) def H := makeMean(0, fn b,x { b+1/x }, fn acc,n { n / acc })</lang>

<lang e>? A(1..10)

  1. value: 5.5

? G(1..10)

  1. value: 4.528728688116765

? H(1..10)

  1. value: 3.414171521474055</lang>

EchoLisp

<lang scheme> (define (A xs) (// (for/sum ((x xs)) x) (length xs)))

(define (G xs) (expt (for/product ((x xs)) x) (// (length xs))))

(define (H xs) (// (length xs) (for/sum ((x xs)) (// x))))

(define xs (range 1 11)) (and (>= (A xs) (G xs)) (>= (G xs) (H xs))) 

   → #t

</lang>

Elixir

<lang elixir>defmodule Means do 

 def arithmetic(list) do
   Enum.sum(list) / length(list)
 end 
 def geometric(list) do
   :math.pow(Enum.reduce(list, &(*/2)), 1 / length(list))
 end 
 def harmonic(list) do
   1 / arithmetic(Enum.map(list, &(1 / &1)))
 end

end

list = Enum.to_list(1..10) IO.puts "Arithmetic mean: #{am = Means.arithmetic(list)}" IO.puts "Geometric mean: #{gm = Means.geometric(list)}" IO.puts "Harmonic mean: #{hm = Means.harmonic(list)}" IO.puts "(#{am} >= #{gm} >= #{hm}) is #{am >= gm and gm >= hm}"</lang>

Output:
Arithmetic mean: 5.5
Geometric mean:  4.528728688116765
Harmonic mean:   3.414171521474055
(5.5 >= 4.528728688116765 >= 3.414171521474055) is true

Erlang

<lang Erlang>%% Author: Abhay Jain <abhay_1303@yahoo.co.in>

-module(mean_calculator). -export([find_mean/0]).

find_mean() -> %% This is function calling. First argument is the the beginning number %% and second argument is the initial value of sum for AM & HM and initial value of product for GM. arithmetic_mean(1, 0), geometric_mean(1, 1), harmonic_mean(1, 0).

%% Function to calculate Arithmetic Mean arithmetic_mean(Number, Sum) when Number > 10 -> AM = Sum / 10, io:format("Arithmetic Mean ~p~n", [AM]); arithmetic_mean(Number, Sum) -> NewSum = Sum + Number, arithmetic_mean(Number+1, NewSum).

%% Function to calculate Geometric Mean geometric_mean(Number, Product) when Number > 10 -> GM = math:pow(Product, 0.1), io:format("Geometric Mean ~p~n", [GM]); geometric_mean(Number, Product) -> NewProd = Product * Number, geometric_mean(Number+1, NewProd).

%% Function to calculate Harmonic Mean harmonic_mean(Number, Sum) when Number > 10 -> HM = 10 / Sum, io:format("Harmonic Mean ~p~n", [HM]); harmonic_mean(Number, Sum) -> NewSum = Sum + (1/Number), harmonic_mean(Number+1, NewSum). </lang>

Output:
Arithmetic Mean 5.5
Geometric Mean 4.528728688116765
Harmonic Mean 3.414171521474055

ERRE

<lang> PROGRAM MEANS

DIM A[9]

PROCEDURE ARITHMETIC_MEAN(A[]->M) 

     LOCAL S,I%
     NEL%=UBOUND(A,1)
     S=0
     FOR I%=0 TO NEL% DO
       S+=A[I%]
     END FOR
     M=S/(NEL%+1)

END PROCEDURE

PROCEDURE GEOMETRIC_MEAN(A[]->M) 

     LOCAL S,I%
     NEL%=UBOUND(A,1)
     S=1
     FOR I%=0 TO NEL% DO
       S*=A[I%]
     END FOR
     M=S^(1/(NEL%+1))

END PROCEDURE

PROCEDURE HARMONIC_MEAN(A[]->M) 

     LOCAL S,I%
     NEL%=UBOUND(A,1)
     S=0
     FOR I%=0 TO NEL% DO
       S+=1/A[I%]
     END FOR
     M=(NEL%+1)/S

END PROCEDURE

BEGIN 

     A[]=(1,2,3,4,5,6,7,8,9,10)
     ARITHMETIC_MEAN(A[]->M)
     PRINT("Arithmetic mean = ";M)
     GEOMETRIC_MEAN(A[]->M)
     PRINT("Geometric mean =  ";M)
     HARMONIC_MEAN(A[]->M)
     PRINT("Harmonic mean =  ";M)

END PROGRAM </lang>

Euler Math Toolbox

<lang Euler Math Toolbox> >function A(x) := mean(x) >function G(x) := exp(mean(log(x))) >function H(x) := 1/mean(1/x) >x=1:10; A(x), G(x), H(x) 

5.5
4.52872868812
3.41417152147

</lang>

Alternatively, e.g.,

<lang Euler Math Toolbox> >function G(x) := prod(x)^(1/length(x)) </lang>

Euphoria

<lang euphoria>function arithmetic_mean(sequence s) 

   atom sum
   if length(s) = 0 then
       return 0
   else
       sum = 0
       for i = 1 to length(s) do   
           sum += s[i]
       end for
       return sum/length(s)
   end if

end function

function geometric_mean(sequence s) 

   atom p
   p = 1
   for i = 1 to length(s) do
       p *= s[i]
   end for
   return power(p,1/length(s))

end function

function harmonic_mean(sequence s) 

   atom sum
   if length(s) = 0 then
       return 0
   else
       sum = 0
       for i = 1 to length(s) do
           sum += 1/s[i]
       end for
       return length(s) / sum
   end if

end function

function true_or_false(atom x) 

   if x then
       return "true"
   else
       return "false"
   end if

end function

constant s = {1,2,3,4,5,6,7,8,9,10} constant arithmetic = arithmetic_mean(s), 

   geometric = geometric_mean(s),
   harmonic = harmonic_mean(s)

printf(1,"Arithmetic: %g\n", arithmetic) printf(1,"Geometric: %g\n", geometric) printf(1,"Harmonic: %g\n", harmonic) printf(1,"Arithmetic>=Geometric>=Harmonic: %s\n", 

   {true_or_false(arithmetic>=geometric and geometric>=harmonic)})</lang>
Output:
Arithmetic: 5.5
Geometric: 4.52873
Harmonic: 3.41417
Arithmetic>=Geometric>=Harmonic: true

Excel

Use the functions : AVERAGE, GEOMEAN and HARMEAN

<lang Excel> =AVERAGE(1;2;3;4;5;6;7;8;9;10) =GEOMEAN(1;2;3;4;5;6;7;8;9;10) =HARMEAN(1;2;3;4;5;6;7;8;9;10) </lang>

Output:
5.5
4.528728688
3,414171521


F#

<lang fsharp>let P = [1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0; 8.0; 9.0; 10.0]

let arithmeticMean (x : float list) = 

   x |> List.sum
     |> (fun acc -> acc / float (List.length(x)))

let geometricMean (x: float list) = 

   x |> List.reduce (*)
     |> (fun acc -> Math.Pow(acc, 1.0 / (float (List.length(x)))))

let harmonicMean (x: float list) = 

   x |> List.map (fun a -> 1.0 / a)
     |> List.sum
     |> (fun acc -> float (List.length(x)) / acc)

printfn "Arithmetic Mean: %A" (arithmeticMean P) printfn "Geometric Mean: %A" (geometricMean P) printfn "Harmonic Mean: %A" (harmonicMean P)</lang>

Factor

<lang factor>: a-mean ( seq -- mean ) 

   [ sum ] [ length ] bi / ;
g-mean ( seq -- mean )
   [ product ] [ length recip ] bi ^ ;
h-mean ( seq -- mean )
   [ length ] [ [ recip ] map-sum ] bi / ;</lang>

( scratchpad ) 10 [1,b] [ a-mean ] [ g-mean ] [ h-mean ] tri
               "%f >= %f >= %f\n" printf
5.500000 >= 4.528729 >= 3.414172

Fantom

<lang fantom> class Main { 

 static Float arithmeticMean (Int[] nums)
 {
   if (nums.size == 0) return 0.0f
   sum := 0
   nums.each |n| { sum += n }
   return sum.toFloat / nums.size
 }

 static Float geometricMean (Int[] nums)
 {
   if (nums.size == 0) return 0.0f
   product := 1
   nums.each |n| { product *= n }
   return product.toFloat.pow(1f/nums.size)
 }

 static Float harmonicMean (Int[] nums)
 {
   if (nums.size == 0) return 0.0f 
   reciprocals := 0f
   nums.each |n| { reciprocals += 1f / n }
   return nums.size.toFloat / reciprocals
 }

 public static Void main ()
 {
   items := (1..10).toList
   // display results
   echo (arithmeticMean (items))
   echo (geometricMean (items))
   echo (harmonicMean (items))
   // check given relation
   if ((arithmeticMean (items) >= geometricMean (items)) &&
       (geometricMean (items) >= harmonicMean (items)))
     echo ("relation holds")
   else
     echo ("relation failed")
 }

} </lang>

Forth

<lang forth>: famean ( faddr n -- f ) 

 0e
 tuck floats bounds do
   i f@ f+
 float +loop
 0 d>f f/ ;
fgmean ( faddr n -- f )
 1e
 tuck floats bounds do
   i f@ f*
 float +loop
 0 d>f 1/f f** ;
fhmean ( faddr n -- f )
 dup 0 d>f  0e
 floats bounds do
   i f@ 1/f f+
 float +loop
 f/ ;

create test 1e f, 2e f, 3e f, 4e f, 5e f, 6e f, 7e f, 8e f, 9e f, 10e f, test 10 famean fdup f. test 10 fgmean fdup fdup f. test 10 fhmean fdup f. ( A G G H ) f>= . f>= . \ -1 -1</lang>

Fortran

Works with: Fortran version 90

<lang fortran>program Mean 

 real :: a(10) = (/ (i, i=1,10) /)
 real :: amean, gmean, hmean

 amean = sum(a) / size(a)
 gmean = product(a)**(1.0/size(a))
 hmean = size(a) / sum(1.0/a)

 if ((amean < gmean) .or. (gmean < hmean)) then
   print*, "Error!" 
 else
   print*, amean, gmean, hmean
 end if

end program Mean</lang>

FunL

<lang funl>import lists.zip

def 

 mean( s, 0 ) = product( s )^(1/s.length())
 mean( s, p ) = (1/s.length() sum( x^p | x <- s ))^(1/p)

def 

 monotone( [_], _ ) = true
 monotone( a1:a2:as, p ) = p( a1, a2 ) and monotone( a2:as, p )

means = [mean( 1..10, m ) | m <- [1, 0, -1]]

for (m, l) <- zip( means, ['Arithmetic', 'Geometric', 'Harmonic'] ) 

 println( "$l: $m" + (if m is Rational then " or ${m.doubleValue()}" else ) )

println( monotone(means, (>=)) )</lang>

Output:
Arithmetic: 11/2 or 5.5
Geometric: 4.528728688116765
Harmonic: 25200/7381 or 3.414171521474055
true

GAP

<lang gap># The first two work with rationals or with floats

  1. (but bear in mind that support of floating point is very poor in GAP)

mean := v -> Sum(v) / Length(v); harmean := v -> Length(v) / Sum(v, Inverse); geomean := v -> EXP_FLOAT(Sum(v, LOG_FLOAT) / Length(v));

mean([1 .. 10]);

  1. 11/2

harmean([1 .. 10]);

  1. 25200/7381

v := List([1..10], FLOAT_INT);; mean(v);

  1. 5.5

harmean(v);

  1. 3.41417

geomean(v);

  1. 4.52873</lang>

Go

<lang go>package main

import ( 

   "fmt"
   "math"

)

func main() { 

   sum, sumr, prod := 0., 0., 1.
   for n := 1.; n <= 10; n++ {
       sum += n
       sumr += 1 / n
       prod *= n
   }
   a, g, h := sum/10, math.Pow(prod, .1), 10/sumr
   fmt.Println("A:", a, "G:", g, "H:", h)
   fmt.Println("A >= G >= H:", a >= g && g >= h)

}</lang>

Output:
A: 5.5 G: 4.528728688116765 H: 3.414171521474055
A >= G >= H: true

Groovy

Solution: <lang groovy>def arithMean = { list -> 

   list == null \
       ? null \
       : list.empty \
           ? 0 \
           : list.sum() / list.size()

}

def geomMean = { list -> 

   list == null \
       ? null \
       : list.empty \
           ? 1 \
           : list.inject(1) { prod, item -> prod*item } ** (1 / list.size())

}

def harmMean = { list -> 

   list == null \
       ? null \
       : list.empty \
           ? 0 \
           : list.size() / list.collect { 1.0/it }.sum()

}</lang>

Test: <lang groovy>def list = 1..10 def A = arithMean(list) def G = geomMean(list) assert A >= G def H = harmMean(list) assert G >= H println """ list: ${list} 

  A: ${A}
  G: ${G}
  H: ${H}

"""</lang>

Output:
list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   A: 5.5
   G: 4.528728688116765
   H: 3.4141715214

Haskell

The general function given here yields an arithmetic mean when its first argument is 1, a geometric mean when its first argument is 0, and a harmonic mean when its first argument is -1.

<lang haskell>import Data.List (genericLength) import Control.Monad (zipWithM_)

mean :: Double -> [Double] -> Double mean 0 xs = product xs ** (1 / genericLength xs) mean p xs = (1 / genericLength xs * sum (map (** p) xs)) ** (1/p)

main = do 

 let ms = zipWith ((. flip mean [1..10]). (,)) "agh" [1, 0, -1]
 mapM_ (\(t,m) -> putStrLn $ t : ": " ++ show m) ms
 putStrLn $ " a >= g >= h is " ++  show ((\(_,[a,g,h])-> a>=g && g>=h) (unzip ms))</lang>

HicEst

<lang HicEst>AGH = ALIAS( A, G, H ) ! named vector elements AGH = (0, 1, 0) DO i = 1, 10 

  A = A + i
  G = G * i
  H = H + 1/i

ENDDO AGH = (A/10, G^0.1, 10/H)

WRITE(ClipBoard, Name) AGH, "Result = " // (A>=G) * (G>=H)</lang> ! A=5.5; G=4.528728688; H=3.414171521; Result = 1;

Icon and Unicon

<lang Icon>link numbers # for a/g/h means

procedure main() every put(x := [], 1 to 10) writes("x := [ "); every writes(!x," "); write("]")

write("Arithmetic mean:", a := amean!x) write("Geometric mean:",g := gmean!x) write("Harmonic mean:", h := hmean!x) write(" a >= g >= h is ", if a >= g >= h then "true" else "false") end </lang>

Library: Icon Programming Library

numbers:amean, numbers:gmean, and numbers:hmean are shown below: <lang Icon>procedure amean(L[]) #: arithmetic mean 

  local m
  if *L = 0 then fail
  m := 0.0
  every m +:= !L
  return m / *L

end

procedure gmean(L[]) #: geometric mean 

  local m
  if *L = 0 then fail
  m := 1.0
  every m *:= !L
  m := abs(m)
  if m > 0.0 then
     return exp (log(m) / *L)
  else
     fail

end

procedure hmean(L[]) #: harmonic mean 

  local m, r
  if *L = 0 then fail
  m := 0.0
  every r := !L do {
     if r = 0.0 then fail
     else m +:= 1.0 / r
     }
  return *L / m

end</lang>

Output:
#means.exe
x := [ 1 2 3 4 5 6 7 8 9 10 ]
Arithmetic mean:5.5
Geometric mean:4.528728688116765
Harmonic mean:3.414171521474055
 a >= g >= h is true

J

Solution: <lang j>amean=: +/ % # gmean=: # %: */ hmean=: amean&.:%</lang>

Example Usage: <lang j> (amean , gmean , hmean) >: i. 10 5.5 4.528729 3.414172 

  assert 2 >:/\ (amean , gmean , hmean) >: i. 10    NB. check amean >= gmean and gmean >= hmean</lang>

Note that gmean could have instead been defined as mean under logarithm, for example:

<lang j>gmean=:amean&.:^.</lang>

Java

<lang java>import java.util.Arrays; import java.util.List;

public class PythagoreanMeans { 

   public static double arithmeticMean(List<Double> numbers) {
       if (numbers.isEmpty()) return Double.NaN;
       double mean = 0.0;
       for (Double number : numbers) {
           mean += number;
       }
       return mean / numbers.size();
   }

   public static double geometricMean(List<Double> numbers) {
       if (numbers.isEmpty()) return Double.NaN;
       double mean = 1.0;
       for (Double number : numbers) {
           mean *= number;
       }
       return Math.pow(mean, 1.0 / numbers.size());
   }

   public static double harmonicMean(List<Double> numbers) {
       if (numbers.isEmpty() || numbers.contains(0.0)) return Double.NaN;
       double mean = 0.0;
       for (Double number : numbers) {
           mean += (1.0 / number);
       }
       return numbers.size() / mean;
   }

   public static void main(String[] args) {
       Double[] array = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
       List<Double> list = Arrays.asList(array);
       double arithmetic = arithmeticMean(list);
       double geometric = geometricMean(list);
       double harmonic = harmonicMean(list);
       System.out.format("A = %f  G = %f  H = %f%n", arithmetic, geometric, harmonic);
       System.out.format("A >= G is %b, G >= H is %b%n", (arithmetic >= geometric), (geometric >= harmonic));
   }

}</lang>

Output:
A = 5.500000  G = 4.528729  H = 3.414172
A >= G is true, G >= H is true
Works with: Java version 1.8

We can rewrite the 3 methods using the new JAVA Stream API: <lang java> 

  public static double arithmAverage(double array[]){
      if (array == null ||array.length == 0) {
        return 0.0;
     }
     else {
        return DoubleStream.of(array).average().getAsDouble();
     }
  }

   public static double geomAverage(double array[]){
     if (array == null ||array.length == 0) {
        return 0.0;
     }
     else {
        double aver = DoubleStream.of(array).reduce(1, (x, y) -> x * y);
        return   Math.pow(aver, 1.0 / array.length);
     }
  }

    public static double harmAverage(double array[]){
        if (array == null ||array.length == 0) {
        return 0.0;
     }
     else {
        double aver = DoubleStream.of(array)
                 // remove null values
                 .filter(n -> n > 0.0)
                 // generate 1/n array
                 .map( n-> 1.0/n)
                 // accumulating
                 .reduce(0, (x, y) -> x + y);
                 // just this reduce is not working- need to do in 2 steps
                // .reduce(0, (x, y) -> 1.0/x + 1.0/y);
        return   array.length / aver ;
     }
  }
 </lang>

JavaScript

Works with: ES5

<lang javascript>(function () { 

   'use strict';

   // arithmetic_mean :: [Number] -> Number
   function arithmetic_mean(ns) {
       return (
           ns.reduce( // sum
               function (sum, n) {
                   return (sum + n);
               },
               0
           ) / ns.length
       );
   }

   // geometric_mean :: [Number] -> Number
   function geometric_mean(ns) {
       return Math.pow(
           ns.reduce( // product
               function (product, n) {
                   return (product * n);
               },
               1
           ),
           1 / ns.length
       );
   }

   // harmonic_mean :: [Number] -> Number
   function harmonic_mean(ns) {
       return (
           ns.length / ns.reduce( // sum of inverses
               function (invSum, n) {
                   return (invSum + (1 / n));
               },
               0
           )
       );
   }

   var values = [arithmetic_mean, geometric_mean, harmonic_mean]
       .map(function (f) {
           return f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
       }),
       mean = {
           Arithmetic: values[0], // arithmetic
           Geometric: values[1], // geometric
           Harmonic: values[2] // harmonic
       }

   return JSON.stringify({
       values: mean,
       test: "is A >= G >= H ? " +
           (
               mean.Arithmetic >= mean.Geometric &&
               mean.Geometric >= mean.Harmonic ? "yes" : "no"
           )
   }, null, 2);

})(); </lang>

Output:

<lang JavaScript>{ 

 "values": {
   "Arithmetic": 5.5,
   "Geometric": 4.528728688116765,
   "Harmonic": 3.414171521474055
 },
 "test": "is A >= G >= H ? yes"

}</lang>

jq

<lang jq>def amean: add/length;

def logProduct: map(log) | add;

def gmean: (logProduct / length) | exp;

def hmean: length / (map(1/.) | add);

  1. Tasks:
[range(1;11) ] | [amean, gmean, hmean] as $ans
| ( $ans[],
  "amean > gmean > hmean => \($ans[0] > $ans[1] and $ans[1] > $ans[2] )" )

</lang>

Output:
5.5
4.528728688116766
3.414171521474055
"amean > gmean > hmean => true"

Julia

Julia has a `mean` function to compute the arithmetic mean of a collections of numbers. We can redefine it as follows. <lang Julia>amean(A) = sum(A)/length(A)

gmean(A) = prod(A)^(1/length(A))

hmean(A) = length(A)/sum(1./A)</lang>

Output:
julia> map(f-> f(1:10), [amean, gmean, hmean]) 
3-element Array{Float64,1}:
 5.5    
 4.52873
 3.41417
julia> ans[1] > ans[2] > ans[3]
true

K

<lang K> 

 am:{(+/x)%#x}
 gm:{(*/x)^(%#x)}
 hm:{(#x)%+/%:'x}
 
 {(am x;gm x;hm x)} 1+!10

5.5 4.528729 3.414172 </lang>

Kotlin

<lang kotlin>fun Collection<Double>.geometricMean() = 

       if (isEmpty())
           Double.NaN
       else Math.pow(reduce { n1, n2 -> n1 * n2 }, 1.0 / size)

fun Collection<Double>.harmonicMean() = 

       if (isEmpty() || contains(0.0))
           Double.NaN
       else
           size / reduce { n1, n2 -> n1 + 1.0 / n2 }

fun main(args: Array<String>) { 

   val list = listOf(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
   val a = list.average()  // arithmetic mean
   val g = list.geometricMean()
   val h = list.harmonicMean()
   println("A = %f  G = %f  H = %f".format(a, g, h))
   println("A >= G is %b, G >= H is %b".format( a >= g, g >= h))
   require(a >= g && g >= h)

}</lang>

Output:
A = 5.500000  G = 4.528729  H = 3.414172
A >= G is true, G >= H is true

Lasso

<lang Lasso>define arithmetic_mean(a::staticarray)::decimal => { //sum of the list divided by its length return (with e in #a sum #e) / decimal(#a->size) } define geometric_mean(a::staticarray)::decimal => { // The geometric mean is the nth root of the product of the list local(prod = 1) with e in #a do => { #prod *= #e } return math_pow(#prod,1/decimal(#a->size)) } define harmonic_mean(a::staticarray)::decimal => { // The harmonic mean is n divided by the sum of the reciprocal of each item in the list return decimal(#a->size)/(with e in #a sum 1/decimal(#e)) }

arithmetic_mean(generateSeries(1,10)->asStaticArray) geometric_mean(generateSeries(1,10)->asStaticArray) harmonic_mean(generateSeries(1,10)->asStaticArray)</lang>

Output:
5.500000
4.528729
3.414172

Liberty BASIC

<lang lb>for i = 1 to 10 

   a = a + i

next ArithmeticMean = a/10

b = 1 for i = 1 to 10 

   b = b * i

next GeometricMean = b ^ (1/10)

for i = 1 to 10 

   c = c + (1/i)

next HarmonicMean = 10/c

print "ArithmeticMean: ";ArithmeticMean print "Geometric Mean: ";GeometricMean print "Harmonic Mean: ";HarmonicMean

if (ArithmeticMean>=GeometricMean) and (GeometricMean>=HarmonicMean) then print "True" else print "False" end if 

</lang>

<lang logo>to compute_means :count 

 local "sum
 make "sum     0
 local "product
 make "product 1
 local "reciprocal_sum
 make "reciprocal_sum  0

 repeat :count [
   make "sum sum :sum repcount
   make "product product :product repcount
   make "reciprocal_sum sum :reciprocal_sum (quotient repcount)
 ]

 output (sentence (quotient :sum :count) (power :product (quotient :count))
                  (quotient :count :reciprocal_sum))

end

make "means compute_means 10 print sentence [Arithmetic mean is] item 1 :means print sentence [Geometric mean is] item 2 :means print sentence [Harmonic mean is] item 3 :means bye</lang>

Lua

<lang lua>function fsum(f, a, ...) return a and f(a) + fsum(f, ...) or 0 end function pymean(t, f, finv) return finv(fsum(f, unpack(t)) / #t) end nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

--arithmetic a = pymean(nums, function(n) return n end, function(n) return n end) --geometric g = pymean(nums, math.log, math.exp) --harmonic h = pymean(nums, function(n) return 1/n end, function(n) return 1/n end) print(a, g, h) assert(a >= g and g >= h)</lang>


Maple

<lang Maple>x := [ seq( 1 .. 10 ) ]; Means := proc( x ) 

   uses Statistics;
   return Mean( x ), GeometricMean( x ), HarmonicMean( x );

end proc: Arithmeticmean, Geometricmean, Harmonicmean := Means( x );

is( Arithmeticmean >= Geometricmean and Geometricmean >= Harmonicmean ); </lang>

Output:
Arithmeticmean, Geometricmean, Harmonicmean := 5.50000000000000, 4.52872868811677, 3.41417152147406

true

Mathematica / Wolfram Language

<lang Mathematica>Print["{Arithmetic Mean, Geometric Mean, Harmonic Mean} = ", 

N@Through[{Mean, GeometricMean, HarmonicMean}[Range@10]]]</lang>
Output:
{Arithmetic Mean, Geometric Mean, Harmonic Mean} = {5.5,4.52873,3.41417}

MATLAB

<lang MATLAB>function [A,G,H] = pythagoreanMeans(list) 

   A = mean(list);
   G = geomean(list);
   H = harmmean(list);

end</lang>

A solution that works for both, Matlab and Octave, is this

<lang MATLAB>function [A,G,H] = pythagoreanMeans(list) 

   A = mean(list);           % arithmetic mean
   G = exp(mean(log(list))); % geometric mean
   H = 1./mean(1./list);     % harmonic mean

end</lang>

Solution: <lang MATLAB>>> [A,G,H]=pythagoreanMeans((1:10))

A = 

  5.500000000000000


G = 

  4.528728688116765


H = 

  3.414171521474055</lang>

Maxima

<lang maxima>/* built-in */ L: makelist(i, i, 1, 10)$

mean(L), numer; /* 5.5 */ geometric_mean(L), numer; /* 4.528728688116765 */ harmonic_mean(L), numer; /* 3.414171521474055 */</lang>

MUMPS

<lang MUMPS>Pyth(n) New a,ii,g,h,x For ii=1:1:n set x(ii)=ii ; ; Average Set a=0 For ii=1:1:n Set a=a+x(ii) Set a=a/n ; ; Geometric Set g=1 For ii=1:1:n Set g=g*x(ii) Set g=g**(1/n) ; ; Harmonic Set h=0 For ii=1:1:n Set h=1/x(ii)+h Set h=n/h ; Write !,"Pythagorean means for 1..",n,":",! Write "Average = ",a," >= Geometric ",g," >= harmonic ",h,! Quit Do Pyth(10)

Pythagorean means for 1..10: Average = 5.5 >= Geometric 4.528728688116178495 >= harmonic 3.414171521474055006</lang>

NetRexx

Translation of: ooRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary

numeric digits 20

a1 = ArrayList(Arrays.asList([Rexx 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])) say "Arithmetic =" arithmeticMean(a1)", Geometric =" geometricMean(a1)", Harmonic =" harmonicMean(a1)

return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method arithmeticMean(numbers = java.util.List) public static returns Rexx 

 -- somewhat arbitrary return for ooRexx
 if numbers.isEmpty then return "NaN"

 mean = 0
 number = Rexx
 loop number over numbers
     mean = mean + number
 end
 return mean / numbers.size

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method geometricMean(numbers = java.util.List) public static returns Rexx 

 -- somewhat arbitrary return for ooRexx
 if numbers.isEmpty then return "NaN"

 mean = 1
 number = Rexx
 loop number over numbers
     mean = mean * number
 end
 return Math.pow(mean, 1 / numbers.size)

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method harmonicMean(numbers = java.util.List) public static returns Rexx 

 -- somewhat arbitrary return for ooRexx
 if numbers.isEmpty then return "NaN"

 mean = 0
 number = Rexx
 loop number over numbers
     if number = 0 then return "Nan"
     mean = mean + (1 / number)
 end

 -- problem here...
 return numbers.size / mean

</lang>

Output:
Arithmetic = 5.5, Geometric = 4.528728688116765, Harmonic = 3.4141715214740550062

Nim

<lang nim>import math, sequtils, future

proc amean(num): float = 

 sum(num) / float(len(num))

proc gmean(num): float = 

 result = 1
 for n in num: result *= n
 result = pow(result, 1.0 / float(num.len))

proc hmean(num): float = 

 for n in num: result += 1.0 / n
 result = float(num.len) / result

proc ameanFunctional(num: seq[float]): float = 

 sum(num) / float(num.len)

proc gmeanFunctional(num: seq[float]): float = 

 num.foldl(a * b).pow(1.0 / float(num.len))

proc hmeanFunctional(num: seq[float]): float = 

 float(num.len) / sum(num.mapIt(float, 1.0 / it))

let numbers = toSeq(1..10).map((x: int) => float(x)) echo amean(numbers), " ", gmean(numbers), " ", hmean(numbers)</lang>

Output:
5.5000000000000000e+00 4.5287286881167654e+00 3.4141715214740551e+00

Oberon-2

Oxford Oberon-2 <lang oberon2> MODULE PythMean; IMPORT Out, ML := MathL;

PROCEDURE Triplets(a: ARRAY OF INTEGER;VAR triplet: ARRAY OF LONGREAL); VAR i: INTEGER; BEGIN triplet[0] := 0.0;triplet[1] := 0.0; triplet[2] := 0.0; FOR i:= 0 TO LEN(a) - 1 DO triplet[0] := triplet[0] + a[i]; triplet[1] := triplet[1] + ML.Ln(a[i]); triplet[2] := triplet[2] + (1 / a[i]) END END Triplets;

PROCEDURE Means*(a: ARRAY OF INTEGER); VAR triplet: ARRAY 3 OF LONGREAL; BEGIN Triplets(a,triplet); Out.String("A(1 .. 10): ");Out.LongReal(triplet[0] / LEN(a));Out.Ln; Out.String("G(1 .. 10): ");Out.LongReal(ML.Exp(triplet[1]/ LEN(a)));Out.Ln; Out.String("H(1 .. 10): ");Out.LongReal(LEN(a) / triplet[2]);Out.Ln; END Means;

VAR nums: ARRAY 10 OF INTEGER; i: INTEGER; BEGIN FOR i := 0 TO LEN(nums) - 1 DO nums[i] := i + 1 END; Means(nums) END PythMean.

</lang>

Output:
A(1 .. 10): 5.50000000000
G(1 .. 10): 4.52872868812
H(1 .. 10): 3.41417152147

Objeck

Translation of: Java

<lang objeck>class PythagMeans { 

 function : Main(args : String[]) ~ Nil {
   array := [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
   arithmetic := ArithmeticMean(array);
   geometric := GeometricMean(array);
   harmonic := HarmonicMean(array);

   arith_geo := arithmetic >= geometric;
   geo_harm := geometric >= harmonic;

   "A = {$arithmetic}, G = {$geometric}, H = {$harmonic}"->PrintLine();
   "A >= G is {$arith_geo}, G >= H is {$geo_harm}"->PrintLine();
 }

 function : native : ArithmeticMean(numbers : Float[]) ~ Float {
   if(numbers->Size() = 0) { return -1.0; };

   mean := 0.0;
   each(i : numbers) {
     mean += numbers[i];
   };

   return mean / numbers->Size();
 }

 function : native : GeometricMean(numbers : Float[]) ~ Float {
   if(numbers->Size() = 0) { return -1.0; };

   mean := 1.0;
   each(i : numbers) {
     mean *= numbers[i];
   };
   
   return mean->Power(1.0 / numbers->Size());
 }

 function : native : HarmonicMean(numbers : Float[]) ~ Float {
   if(numbers->Size() = 0) { return -1.0; };

   mean := 0.0;
   each(i : numbers) {
     mean += (1.0 / numbers[i]);
   };
   
   return numbers->Size() / mean;
 }

}</lang>

Output: 

A = 5.500, G = 4.529, H = 3.414
A >= G is true, G >= H is true

OCaml

The three means in one function

<lang ocaml>let means v = 

 let n = Array.length v
 and a = ref 0.0
 and b = ref 1.0
 and c = ref 0.0 in
 for i=0 to n-1 do
   a := !a +. v.(i);
   b := !b *. v.(i);
   c := !c +. 1.0/.v.(i);
 done;
 let nn = float_of_int n in
 (!a /. nn, !b ** (1.0/.nn), nn /. !c)
</lang>
Output:
means (Array.init 10 (function i -> (float_of_int (i+1)))) ;;
(* (5.5, 4.5287286881167654, 3.4141715214740551) *)

Another implementation using Array.fold_left instead of a for loop:

<lang ocaml>let means v = 

 let (a, b, c) =
   Array.fold_left
     (fun (a, b, c) x -> (a+.x, b*.x, c+.1./.x))
     (0.,1.,0.) v
 in
 let n = float_of_int (Array.length v) in
 (a /. n, b ** (1./.n), n /. c)
</lang>

Octave

<lang Octave> 

   A = mean(list);     % arithmetic mean
   G = mean(list,'g'); % geometric mean
   H = mean(list,'a'); % harmonic mean

</lang>

See also Matlab implementation #MATLAB

Oforth

<lang Oforth>: A(l) l avg ;

G(l) l prod l size inv powf ;
H(l) l size l map(#inv) sum / ;
averages

| g | 

  "Geometric mean  :" . G(10 seq) dup .cr ->g
  "Arithmetic mean :" . A(10 seq) dup . g >= ifTrue: [ " ==> A >= G" .cr ]
  "Harmonic mean   :" . H(10 seq) dup . g <= ifTrue: [ " ==> G >= H" .cr ] ;</lang>
Output:
Geometric mean  : 4.52872868811677
Arithmetic mean : 5.5 ==> A >= G
Harmonic mean   : 3.41417152147406 ==> G >= H

ooRexx

<lang ooRexx> a = .array~of(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0) say "Arithmetic =" arithmeticMean(a)", Geometric =" geometricMean(a)", Harmonic =" harmonicMean(a)

routine arithmeticMean
 use arg numbers
 -- somewhat arbitrary return for ooRexx
 if numbers~isEmpty then return "NaN"

 mean = 0
 loop number over numbers
     mean += number
 end
 return mean / numbers~items
routine geometricMean
 use arg numbers
 -- somewhat arbitrary return for ooRexx
 if numbers~isEmpty then return "NaN"

 mean = 1
 loop number over numbers
     mean *= number
 end

 return rxcalcPower(mean, 1 / numbers~items)
routine harmonicMean
 use arg numbers
 -- somewhat arbitrary return for ooRexx
 if numbers~isEmpty then return "NaN"

 mean = 0
 loop number over numbers
     if number = 0 then return "Nan"
     mean += 1 / number
 end

 -- problem here....
 return numbers~items / mean
requires rxmath LIBRARY

</lang>

Oz

<lang oz>declare 

 %% helpers
 fun {Sum Xs} {FoldL Xs Number.'+' 0.0} end
 fun {Product Xs} {FoldL Xs Number.'*' 1.0} end
 fun {Len Xs} {Int.toFloat {Length Xs}} end

 fun {AMean Xs}
    {Sum Xs}
    /
    {Len Xs}
 end

 fun {GMean Xs}
    {Pow
     {Product Xs}
     1.0/{Len Xs}}
 end

 fun {HMean Xs}
    {Len Xs}
    /
    {Sum {Map Xs fun {$ X} 1.0 / X end}}
 end

 Numbers = {Map {List.number 1 10 1} Int.toFloat}

 [A G H] = [{AMean Numbers} {GMean Numbers} {HMean Numbers}]

in 

 {Show [A G H]}
 A >= G = true
 G >= H = true</lang>

PARI/GP

General implementations: <lang parigp>arithmetic(v)={ 

 sum(i=1,#v,v[i])/#v

}; geometric(v)={ 

 prod(i=1,#v,v[i])^(1/#v)

}; harmonic(v)={ 

 #v/sum(i=1,#v,1/v[i])

};

v=vector(10,i,i); [arithmetic(v),geometric(v),harmonic(v)]</lang>

Specific to the first n positive integers: <lang parigp>arithmetic_first(n)={ 

 (n+1)/2

}; geometric_first(n)={ 

 n!^(1/n)

}; harmonic_first(n)={ 

 n/if(n>1000,
   log(n)+Euler+1/(n+n)+1/(12*n^2)-1/(120*n^4)+1/(252*n^6)-1/(240*n^8)+1/(132*n^10)
 ,
   n/sum(k=1,n,1/k)
 )

};

[arithmetic_first(10),geometric_first(10),harmonic_first(10)] %[1]>=%[2] && %[2] >= %[3]</lang>

These are, asymptotically, n/2, n/e, and n/log n.

Pascal

See Delphi

Perl

<lang perl>sub A { 

       my $a = 0;
       $a += $_ for @_;
       return $a / @_;

} sub G { 

       my $p = 1;
       $p *= $_ for @_;
       return  $p**(1/@_); # power of 1/n == root of n

} sub H { 

       my $h = 0;
       $h += 1/$_ for @_;
       return @_/$h;

} my @ints = (1..10);

my $a = A(@ints); my $g = G(@ints); my $h = H(@ints);

print "A=$a\nG=$g\nH=$h\n"; die "Error" unless $a >= $g and $g >= $h;</lang>

Perl 6

Works with: Rakudo version 2015.12

<lang Perl6>sub A { ([+] @_) / @_ } sub G { ([*] @_) ** (1 / @_) } sub H { @_ / [+] 1 X/ @_ }

say "A(1,...,10) = ", A(1..10); say "G(1,...,10) = ", G(1..10); say "H(1,...,10) = ", H(1..10); </lang>

Output:
A(1,...,10) = 5.5
G(1,...,10) = 4.52872868811677
H(1,...,10) = 3.41417152147406

Phix

(note to self: iff should really be a builtin) <lang Phix>function arithmetic_mean(sequence s) 

   return sum(s)/length(s)

end function

function geometric_mean(sequence s) atom p = 1 

   for i=1 to length(s) do
       p *= s[i]
   end for
   return power(p,1/length(s))

end function

function harmonic_mean(sequence s) atom rsum = 0 

   for i=1 to length(s) do
       rsum += 1/s[i]
   end for
   return length(s)/rsum

end function

function iff(integer condition, object Tval, object Fval) 

   if condition then return Tval else return Fval end if

end function

constant s = {1,2,3,4,5,6,7,8,9,10} constant arithmetic = arithmetic_mean(s), 

        geometric = geometric_mean(s),
        harmonic = harmonic_mean(s)

printf(1,"Arithmetic: %.10g\n", arithmetic) printf(1,"Geometric: %.10g\n", geometric) printf(1,"Harmonic: %.10g\n", harmonic) printf(1,"Arithmetic>=Geometric>=Harmonic: %s\n", {iff((arithmetic>=geometric and geometric>=harmonic),"true","false")})</lang>

Output:
Arithmetic: 5.5
Geometric: 4.528728688
Harmonic: 3.414171521
Arithmetic>=Geometric>=Harmonic: true

PHP

<lang PHP><?php // Created with PHP 7.0

function ArithmeticMean(array $values) { 

   return array_sum($values) / count($values);

}

function GeometricMean(array $values) { 

   return array_product($values) ** (1 / count($values));

}

function HarmonicMean(array $values) { 

   $sum = 0;

   foreach ($values as $value) {
       $sum += 1 / $value;
   }

   return count($values) / $sum;

}

$values = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

echo "Arithmetic: " . ArithmeticMean($values) . "\n"; echo "Geometric: " . GeometricMean($values) . "\n"; echo "Harmonic: " . HarmonicMean($values) . "\n"; </lang>

Output:
Arithmetic: 5.5
Geometric: 4.5287286881168
Harmonic: 3.4141715214741

PicoLisp

<lang PicoLisp>(load "@lib/math.l")

(let (Lst (1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0) Len (length Lst)) 

  (prinl "Arithmetic mean: "
     (format
        (/ (apply + Lst) Len)
        *Scl ) )
  (prinl "Geometric mean: "
     (format
        (pow (*/ (apply * Lst) (** 1.0 (dec Len))) (/ 1.0 Len))
        *Scl ) )
  (prinl "Harmonic mean: "
     (format
        (*/ (* 1.0 Len) 1.0 (sum '((N) (*/ 1.0 1.0 N)) Lst))
        *Scl ) ) )</lang>
Output:
Arithmetic mean: 5.500000
Geometric mean: 4.528729
Harmonic mean: 3.414172

PL/I

<lang PL/I> declare n fixed binary, 

       (Average, Geometric, Harmonic) float;

declare A(10) float static initial (1,2,3,4,5,6,7,8,9,10);

n = hbound(A,1);

/* compute the average */ Average = sum(A)/n;

/* Compute the geometric mean: */ Geometric = prod(A)**(1/n);

/* Compute the Harmonic mean: */ Harmonic = n / sum(1/A);

put skip data (Average); put skip data (Geometric); put skip data (Harmonic);

if Average < Geometric then put skip list ('Error'); if Geometric < Harmonic then put skip list ('Error'); </lang> Results: 

AVERAGE= 5.50000E+0000;
GEOMETRIC= 4.52873E+0000;
HARMONIC= 3.41417E+0000;

PostScript

<lang> /pythamean{ /x exch def /sum 0 def /prod 1 def /invsum 0 def /i 1 def

x{ /sum sum i add def /prod prod i mul def /invsum invsum i -1 exp add def /i i 1 add def }repeat (Arithmetic Mean : ) print sum x div = (Geometric Mean : ) print prod x -1 exp exp = (Harmonic Mean : ) print x invsum div = }def

10 pythamean </lang>

Output:
Arithmetic Mean : 5.5
Geometric Mean : 4.52873
Harmonic Mean : 3.41417
Library: initlib

<lang postscript> /numbers {[1 10] 1 range}. /recip {1 exch div}.

% Arithmetic mean numbers dup 0 {+} fold exch length div % Geometric mean numbers dup 1 {*} fold exch length recip exp % Harmonic mean numbers dup 0 {recip +} fold exch length exch div </lang>

PowerShell

<lang PowerShell>$A = 0 $LogG = 0 $InvH = 0

$ii = 1..10 foreach($i in $ii) { # Arithmetic mean is computed directly $A += $i / $ii.Count # Geometric mean is computed using Logarithms $LogG += [Math]::Log($i) / $ii.Count # Harmonic mean is computed using its inverse $InvH += 1 / ($i * $ii.Count) }

$G = [Math]::Exp($LogG) $H = 1/$InvH

write-host "Arithmetic mean: A = $A" write-host "Geometric mean: G = $G" write-host "Harmonic mean: H = $H"

write-host "Is A >= G ? $($A -ge $G)" write-host "Is G >= H ? $($G -ge $H)"</lang>

Output:
Arithmetic mean: A = 5.5
Geometric mean:  G = 4.52872868811676
Harmonic mean:   H = 3.41417152147405
Is A >= G ? True
Is G >= H ? True

PureBasic

<lang PureBasic>Procedure.d ArithmeticMean() 

 For a = 1 To 10
   mean + a
 Next
 ProcedureReturn mean / 10

EndProcedure Procedure.d GeometricMean() 

 mean = 1
 For a = 1 To 10
   mean * a
 Next
 ProcedureReturn Pow(mean, 1 / 10)

EndProcedure Procedure.d HarmonicMean() 

 For a = 1 To 10
   mean.d + 1 / a
 Next
 ProcedureReturn 10 / mean

EndProcedure

If HarmonicMean() <= GeometricMean() And GeometricMean() <= ArithmeticMean() 

 Debug "true"

EndIf Debug ArithmeticMean() Debug GeometricMean() Debug HarmonicMean()</lang>

Python

Works with: Python version 3

<lang Python>from operator import mul from functools import reduce

def amean(num): return sum(num)/len(num)

def gmean(num): return reduce(mul, num, 1)**(1/len(num))

def hmean(num): return len(num)/sum(1/n for n in num)

numbers = range(1,11) # 1..10 a, g, h = amean(numbers), gmean(numbers), hmean(numbers) print(a, g, h) assert( a >= g >= h ) </lang>

Output:
5.5 4.52872868812 3.41417152147

These are the same in Python 2 apart from requiring explicit float division (either through float() casts or float literals such as 1./n); or better, do a from __future__ import division, which works on Python 2.2+ as well as Python 3, and makes division work consistently like it does in Python 3.

R

Initialise x <lang R> 

x <- 1:10

</lang> Arithmetic mean <lang R> a <- sum(x)/length(x)

</lang> or <lang R> a <- mean(x) </lang>

The geometric mean <lang R> g <- prod(x)^(1/length(x)) </lang>

The harmonic mean (no error checking that ) <lang R> h <- length(x)/sum(1/x) </lang>

Then:

<lang R> a > g </lang>

and

<lang R> g > h </lang>

give both 

[1] TRUE

Racket

<lang racket>

  1. lang racket

(define (arithmetic xs) 

 (/ (for/sum ([x xs]) x)
    (length xs)))

(define (geometric xs) 

 (expt (for/product ([x xs]) x)
       (/ (length xs))))

(define (harmonic xs) 

 (/ (length xs)
    (for/sum ([x xs]) (/ x))))

(define xs (range 1 11)) (arithmetic xs) (geometric xs) (harmonic xs) (>= (arithmetic xs) (geometric xs) (harmonic xs)) </lang>

Output:
5 1/2
4.528728688116765
3 3057/7381
#t

REXX

REXX doesn't have a   POW   function, so an   IROOT   (integer root)   function is included here.

Coding note:   while the   do   loop flow looks nice, it took a bit of work to get exactly right,   and doesn't lend itself to being updated easily. <lang rexx>/*REXX program computes and displays the Pythagorean means [Amean, Gmean, Hmean]. */ parse arg n . /*obtain the optional argument from CL.*/ if n== then n=10 /*None specified? Then assume default.*/ sum=0 /*▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ compute Arithmetic mean. ▒▒▒▒▒▒▒▒▒▒▒▒*/ 

                    do a=1  for n;   @.a=a      /*populate the array and calculate sum.*/
                    sum=sum + @.a               /*compute the sum of all the elements. */
                    end    /*a*/

Amean=sum/n /*calculate the arithmetic mean. */ say 'Amean =' Amean /*display " " " */ prod=1 /*▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ compute Geometric mean. ▒▒▒▒▒▒▒▒▒▒▒▒▒*/ 

                    do g=1  for n
                    prod=prod * @.g             /*compute the product of all elements. */
                    end    /*g*/

Gmean=Iroot(prod,n) /*calculate the geometric mean. */ say 'Gmean =' Gmean /*display " " " */ rsum=0 /*▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ compute Harmonic mean. ▒▒▒▒▒▒▒▒▒▒▒▒▒▒*/ 

                    do r=1  for n
                    rsum=rsum + 1/@.r           /*compute the sum of the reciprocals.  */
                    end    /*r*/

Hmean=n/rsum /*calculate the harmonic mean. */ say 'Hmean =' Hmean /*display " " " */ exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ Iroot: procedure; arg x 1 ox, y 1 oy /*get both args, and also a copy of X&Y*/ if x=0 | x=1 then return x /*handle special case of zero and unity*/ if y=0 then return 1 /* " " " " a zero root.*/ if y=1 then return x /* " " " " a unity root.*/ if x<0 & y//2==0 then do; say /*check for an illegal combination. */ 

                          say '*** error *** (from Iroot):';                          say
                          say 'root'   y   "can't be even if first argument is < 0."; say
                          return '[n/a]'        /*return a  "not applicable"  string.  */
                      end                       /* [↑]  Y<0  yields a complex number.  */

x=abs(x); y=abs(y); m=y-1 /*use the absolute value for X and Y. */ digO=digits() /*save original accuracy (decimal digs)*/ a=digO+5 /*use an extra five digs " " */ g=(x+1) / y**y /*use this as the first guesstimate. */ d=5 /*Start with 5 decimal digit accuracy. When the digits is large, */ 

                     /*CPU time is wasted when the (1st) guess isn't close to the root.*/

 do forever   /* ◄════════════════════════════╗ keep plugging as digits are increased. */
 d=min(d+d,a)                         /*      ║ limit the digits to original digitss+5.*/
 numeric digits d                     /*      ║ keep increasing the dec. digit accuracy*/
 old=.                                /*      ║ define the old (value) for 1st compare.*/
                                      /*      ║                                        */
   do forever   /* ◄──────────────────────┐   ║ keep plugging at the   Yth   root.     */
   _=format((m*g**y+x)/y/g**m,,d-2)   /*  │   ║ this is the nitty─gritty stuff.        */
   if _=g | _=old then leave          /*  |   ║ are we close enough yet?               */
   old=g;   g=_                       /*  │   ║ save guess to old);  set the new guess.*/
   end   /*forever ►──────────────────────┘   ║                                        */
                                      /*      ║                                        */
 if d==a then leave                   /*      ║ are we at desired dec. digit accuracy? */
 end     /*forever ►══════════════════════════╝                                        */

_=g*sign(ox); if oy<0 then _=1/_ /*adjust for original X sign; neg. root*/ numeric digits digO; return _/1 /*normalize to original decimal digits.*/</lang> output   using the default inputs: 

Amean = 5.5
Gmean = 4.52872869
Hmean = 3.41417153

Ring

<lang ring> decimals(8) array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] see "arithmetic mean = " + arithmeticMean(array) + nl see "geometric mean = " + geometricMean(array) + nl see "harmonic mean = " + harmonicMean(array) + nl

func arithmeticMean a 

    return summary(a) / len(a)

func geometricMean a 

    b = 1
    for i = 1 to len(a)
        b *= a[i]
    next
    return pow(b, (1/len(a)))

func harmonicMean a 

    b = list(len(a))
    for nr = 1 to len(a)
        b[nr] = 1/a[nr]
    next 
    return len(a) / summary(b)

func summary s 

    sum = 0
    for n = 1 to len(s)
        sum += s[n]
    next  
    return sum

</lang> Output: 

arithmetic mean = 5.50000000
geometric mean =  4.52872869
harmonic mean =  3.41417152

Ruby

Works with: Ruby version 1.9+

<lang ruby>class Array 

 def arithmetic_mean
   inject(0.0, :+) / length
 end
 
 def geometric_mean
   inject(:*) ** (1.0 / length)
 end
 
 def harmonic_mean
   length / inject(0.0) {|s, m| s + 1.0/m}
 end

end

class Range 

 def method_missing(m, *args)
   case m
   when /_mean$/ then to_a.send(m)
   else super
   end
 end

end

p a = (1..10).arithmetic_mean p g = (1..10).geometric_mean p h = (1..10).harmonic_mean

  1. is h < g < a ??

p g.between?(h, a)</lang>

Output:
5.5
4.528728688116765
3.414171521474055
true

Run BASIC

<lang runbasic>bXsum = 1 for i = 1 to 10 

 sum   = sum + i                ' sum of 1 -> 10
 bXsum = bXsum * i              ' sum i * i
 sum1i = sum1i + (1/i)          ' sum 1/i

next

average = sum / 10 geometric = bXsum ^ (1/10) harmonic = 10/sum1i 

print "ArithmeticMean:";average
print "Geometric Mean:";geometric
print " Harmonic Mean:";harmonic
 
if (average >= geometric) and (geometric >= harmonic) then print "True" else print "False"</lang>
Output:
Arithmetic Mean:5.5
 Geometric Mean:4.52872869
  Harmonic Mean:3.41417132
True

Rust

<lang rust>fn main() { 

   let mut sum = 0.0;
   let mut prod = 1;
   let mut recsum = 0.0;
   for i in 1..11{
       sum += i as f32;
       prod *= i;
       recsum += 1.0/(i as f32);
   } 
   let avg = sum/10.0;
   let gmean = (prod as f32).powf(0.1);
   let hmean = 10.0/recsum;
   println!("Average: {}, Geometric mean: {}, Harmonic mean: {}", avg, gmean, hmean);
   assert!( ( (avg >= gmean) && (gmean >= hmean) ), "Incorrect calculation");

} </lang>

Output:
Average: 5.5, Geometric mean:4.528729, Harmonic mean: 3.4141712

Scala

Works with: Scala version 2.8+

<lang scala>def arithmeticMean(n: Seq[Int]) = n.sum / n.size.toDouble def geometricMean(n: Seq[Int]) = math.pow(n.foldLeft(1.0)(_*_), 1.0 / n.size.toDouble) def harmonicMean(n: Seq[Int]) = n.size / n.map(1.0 / _).sum

var nums = 1 to 10 var a = arithmeticMean(nums) var g = geometricMean(nums) var h = harmonicMean(nums)

println("Arithmetic mean " + a) println("Geometric mean " + g) println("Harmonic mean " + h)

assert(a >= g && g >= h)</lang>

Output:
Arithmetic mean 5.5
Geometric mean  4.528728688116765
Harmonic mean   3.414171521474055

Scheme

Works with: Scheme version RRS

<lang scheme>(define (a-mean l) 

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

(define (g-mean l) 

 (expt (apply * l) (/ (length l))))

(define (h-mean l) 

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

(define (iota start stop) 

 (if (> start stop)
     (list)
     (cons start (iota (+ start 1) stop))))

(let* ((l (iota 1 10)) (a (a-mean l)) (g (g-mean l)) (h (h-mean l))) 

 (display a)
 (display " >= ")
 (display g)
 (display " >= ")
 (display h)
 (newline)
 (display (>= a g h))
 (newline))</lang>
Output:

<lang>11/2 >= 4.528728688116765 >= 25200/7381

  1. t</lang>

Seed7

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

 include "float.s7i";

const array float: numbers is [] (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);

const func proc: main is func 

 local
   var float: number is 0.0;
   var float: sum is 0.0;
   var float: product is 1.0;
   var float: reciprocalSum is 0.0;
 begin
   for number range numbers do
     sum +:= number;
     product *:= number;
     reciprocalSum +:= 1.0 / number;
   end for;
   writeln("Arithmetic mean: " <& sum / flt(length(numbers)));
   writeln("Geometric mean:  " <& product ** (1.0 / flt(length(numbers))));
   writeln("Harmonic mean:   " <& flt(length(numbers)) / reciprocalSum);
 end func;</lang>
Output:
Arithmetic mean: 5.5
Geometric mean:  4.528728961944580078125
Harmonic mean:   3.4141712188720703125

Sidef

<lang sidef>func A(a) { a.sum / a.len } func G(a) { a.prod.root(a.len) } func H(a) { a.len / a.map{1/_}.sum }</lang>

The same thing, using hyper-operators: <lang sidef>func A(a) { a«+» / a.len } func G(a) { a«*» ** (1/a.len) } func H(a) { a.len / (a«/«1 «+») }</lang>

Calling the functions: <lang sidef>say("A(1,...,10) = ", A(1..10)); say("G(1,...,10) = ", G(1..10)); say("H(1,...,10) = ", H(1..10));</lang>

Output:
A(1,...,10) = 5.5
G(1,...,10) = 4.528728688116764762203309337195508793499
H(1,...,10) = 3.414171521474055006096734859775098225173

Smalltalk

Works with: GNU Smalltalk

This extends the class Collection, so these three methods can be called over any kind of collection, it is enough the the objects of the collection understand +, *, raisedTo, reciprocal and /.

<lang smalltalk>Collection extend [ 

   arithmeticMean
   [

^ (self fold: [:a :b| a + b ]) / (self size) 

   ]

   geometricMean
   [

^ (self fold: [:a :b| a * b]) raisedTo: (self size reciprocal) 

   ]

   harmonicMean
   [

^ (self size) / ((self collect: [:x|x reciprocal]) fold: [:a :b| a + b ] ) 

   ]

]

|a| a := #(1 2 3 4 5 6 7 8 9 10).

a arithmeticMean asFloat displayNl. a geometricMean asFloat displayNl. a harmonicMean asFloat displayNl.

((a arithmeticMean) >= (a geometricMean)) displayNl. ((a geometricMean) >= (a harmonicMean)) displayNl.</lang>

Output:
5.5
4.528728688116765
3.414171521474055
true
true

Tcl

<lang tcl>proc arithmeticMean list { 

   set sum 0.0
   foreach value $list { set sum [expr {$sum + $value}] }
   return [expr {$sum / [llength $list]}]

} proc geometricMean list { 

   set product 1.0
   foreach value $list { set product [expr {$product * $value}] }
   return [expr {$product ** (1.0/[llength $list])}]

} proc harmonicMean list { 

   set sum 0.0
   foreach value $list { set sum [expr {$sum + 1.0/$value}] }
   return [expr {[llength $list] / $sum}]

}

set nums {1 2 3 4 5 6 7 8 9 10} set A10 [arithmeticMean $nums] set G10 [geometricMean $nums] set H10 [harmonicMean $nums] puts "A10=$A10, G10=$G10, H10=$H10" if {$A10 >= $G10} { puts "A10 >= G10" } if {$G10 >= $H10} { puts "G10 >= H10" }</lang>

Output:
A10=5.5, G10=4.528728688116765, H10=3.414171521474055
A10 >= G10
G10 >= H10

Ursala

<lang Ursala>#import std

  1. import flo

data = ari10(1.,10.) # arithmetic progression, length 10 with endpoints 1 and 10

a = mean data g = exp mean ln* data h = div/1. mean div/*1. data

  1. cast %eLbX

main = ^(~&,ordered not fleq) <a,g,h></lang>

Output:
(
   <5.500000e+00,4.528729e+00,3.414172e+00>,
   true)

Vala

Most valac setups will need "-X -lm" added to the compile command to include the C math library.

<lang vala> double arithmetic(int[] list){ double mean; double sum = 0; foreach(int number in list){ sum += number; } // foreach

mean = sum / list.length;

return mean; } // end arithmetic mean

double geometric(int[] list){ double mean; double product = 1; foreach(int number in list){ product *= number; } // foreach

mean = Math.pow(product, (1 / (double) list.length));

return mean; } // end geometric mean

double harmonic(int[] list){ double mean; double sum_inverse = 0; foreach(int number in list){ sum_inverse += (1 / (double) number); } // foreach

mean = (double) list.length / sum_inverse;

return mean; } // end harmonic mean

public static void main(){ int[] list = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

double arithmetic_mean = arithmetic(list); double geometric_mean = geometric(list); double harmonic_mean = harmonic(list);

// should be 5.5 stdout.printf("Arithmetic mean: %s\n", arithmetic_mean.to_string());

// should be 4.528728688116765 stdout.printf("Geometric mean: %s\n", geometric_mean.to_string());

// should be 4.528728688116765 stdout.printf("Harmonic mean: %s\n", harmonic_mean.to_string()); } </lang>

Output:
Arithmetic mean: 5.5
Geometric mean: 4.5287286881167654
Harmonic mean: 3.4141715214740551

VBScript

<lang vb> Function arithmetic_mean(arr) sum = 0 For i = 0 To UBound(arr) sum = sum + arr(i) Next arithmetic_mean = sum / (UBound(arr)+1) End Function

Function geometric_mean(arr) product = 1 For i = 0 To UBound(arr) product = product * arr(i) Next geometric_mean = product ^ (1/(UBound(arr)+1)) End Function

Function harmonic_mean(arr) sum = 0 For i = 0 To UBound(arr) sum = sum + (1/arr(i)) Next harmonic_mean = (UBound(arr)+1) / sum End Function

WScript.StdOut.WriteLine arithmetic_mean(Array(1,2,3,4,5,6,7,8,9,10)) WScript.StdOut.WriteLine geometric_mean(Array(1,2,3,4,5,6,7,8,9,10)) WScript.StdOut.WriteLine harmonic_mean(Array(1,2,3,4,5,6,7,8,9,10)) </lang>

Output:
5.5
4.52872868811677
3.41417152147406

XPL0

<lang XPL0>include c:\cxpl\codes;

func real Power(X, Y); \X raised to the Y power real X, Y; \ (from StdLib.xpl) return Exp(Y * Ln(X));

int N, Order; real R, A, A1, G, G1, H, H1; [A1:= 0.0; G1:= 1.0; H1:= 0.0; Order:= true; for N:= 1 to 10 do 

       [R:= float(N);          \convert integer N to real R
       A1:= A1 + R;
       A:= A1/R;               \arithmetic mean
       G1:= G1 * R;
       G:= Power(G1, 1.0/R);   \geometric mean (Nth root of G1)
       if G>A then Order:= false;
       H1:= H1 + 1.0/R;
       H:= R/H1;               \harmonic mean
       if H>G then Order:= false;
       ];

RlOut(0, A); CrLf(0); RlOut(0, G); CrLf(0); RlOut(0, H); CrLf(0); if not Order then Text(0, "NOT "); Text(0, "ALWAYS DECREASING ORDER "); ]</lang>

Output:
    5.50000
    4.52873
    3.41417
ALWAYS DECREASING ORDER

zkl

<lang zkl>var ns=T(1,2,3,4,5,6,7,8,9,10); ns.sum(0.0)/ns.len(); //Arithmetic mean ns.reduce('*,1.0).pow(1.0/ns.len()); //Geometric mean ns.len().toFloat() / ns.reduce(fcn(p,n){p+1.0/n},0.0); //Harmonic mean</lang>

Output:
5.5
4.52873
3.41417
Retrieved from "https://rosettacode.org/wiki/Averages/Pythagorean_means?oldid=140032"