Averages/Pythagorean means: Difference between revisions

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

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

print(amean(numbers))

print(gmean(numbers))

{{out}}

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

{{libheader|Action! Tool Kit}}

PROC InverseI(INT a,result)

HarmonicMean(a,10,result)

Print(" Harmonic mean=") PrintRE(result)

{{out}}

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

=={{header|ActionScript}}==

{

var sum:Number = 0;

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

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

=={{header|Ada}}==

pythagorean_means.ads:

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;

pythagorean_means.adb:

package body Pythagorean_Means is

package Math is new Ada.Numerics.Generic_Elementary_Functions (Float);

end Harmonic_Mean;

example main.adb:

with Pythagorean_Means;

procedure Main is

Float'Image (Geometric_Mean) & " >= " &

Float'Image (Harmonic_Mean));

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

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

printf(($"Geometric mean = "f(real)l$,prod**(1/count)));

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

Lunix command:

a68g Averages_Pythagorean_means.a68 - 1 2 3 4 5 6 7 8 9 10

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

% returns the arithmetic mean of the elements of n from lo to hi %

real procedure arithmeticMean ( real array n ( * ); integer value lo, hi ) ;

write( "Harmonic mean: ", harmonicMean( v, 1, 10 ) )

{{out}}

<pre>

=={{header|Amazing Hopper}}==

Think about "talk" programming...

#include <hopper.h>

stats(HARMEAN)

back

{{out}}

<pre>

=={{header|APL}}==

arithmetic←{(+/⍵)÷⍴⍵}

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

4.528728688

harmonic x

=={{header|AppleScript}}==

{{trans|JavaScript}}

on arithmetic_mean(xs)

end script

end if

{{Out}}

=={{header|Arturo}}==

average arr

print arithmeticMean 1..10

print geometricMean 1..10

{{out}}

=={{header|AutoHotkey}}==

G := GeometricMean(1, 10)

H := HarmonicMean(1, 10)

Sum += 1 / (a + A_Index - 1)

Return, n / Sum

Message box shows:

<pre>

=={{header|AWK}}==

{

x = $1; # value of 1st column

print "Geometric mean : ",exp(G/N);

print "Harmonic mean : ",N/H;

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

The arithmetic and harmonic means use BBC BASIC's built-in array operations; only the geometric mean needs a loop.

a() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

PRINT "Arithmetic mean = " ; FNarithmeticmean(a())

b() = 1/a()

= (DIM(a(),1)+1) / SUM(b())

{{out}}

<pre>Arithmetic mean = 5.5

=={{header|C}}==

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

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

return 0;

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

{{works with|C sharp|C#|3}}

using System.Collections.Generic;

using System.Diagnostics;

}

}

{{out}}

<pre>

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

#include <iostream>

#include <numeric>

<< geometric_mean << " and the harmonic mean " << harmonic_mean << " !\n" ;

return 0 ;

{{out}}

<pre>The arithmetic mean is 5.5 , the geometric mean 4.52873 and the harmonic mean 3.41417 !</pre>

=={{header|Clojure}}==

(defn a-mean [coll]

a (a-mean numbers) g (g-mean numbers) h (h-mean numbers)]

(println a ">=" g ">=" h)

=={{header|CoffeeScript}}==

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

console.log "A = ", A, " G = ", G, " H = ", H

{{out}}

<pre>A = 5.5 G = 4.528728688116765 H = 3.414171521474055

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

The output for the harmonic mean is wrong.

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

writefln("%(%.19f %)", m);

assert(m.isSorted);

{{out}}

<pre>0.9891573712076470036 4.5287286881167647619 5.5000000000000000000</pre>

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

else

writeln("Error!");

=={{header|E}}==

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

return def mean(numbers) {

var count := 0

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

# value: 5.5

? H(1..10)

=={{header|EchoLisp}}==

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

(and (>= (A xs) (G xs)) (>= (G xs) (H xs)))

→ #t

=={{header|Elixir}}==

def arithmetic(list) do

Enum.sum(list) / length(list)

IO.puts "Geometric mean: #{gm = Means.geometric(list)}"

IO.puts "Harmonic mean: #{hm = Means.harmonic(list)}"

{{out}}

<pre>

=={{header|Erlang}}==

-module(mean_calculator).

harmonic_mean(Number, Sum) ->

NewSum = Sum + (1/Number),

{{out}}

PRINT("Harmonic mean = ";M)

END PROGRAM

=={{header|Euler Math Toolbox}}==

>function A(x) := mean(x)

>function G(x) := exp(mean(log(x)))

4.52872868812

3.41417152147

Alternatively, e.g.,

>function G(x) := prod(x)^(1/length(x))

=={{header|Euphoria}}==

atom sum

if length(s) = 0 then

printf(1,"Harmonic: %g\n", harmonic)

printf(1,"Arithmetic>=Geometric>=Harmonic: %s\n",

{{out}}

Use the functions : AVERAGE, GEOMEAN and HARMEAN

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

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

let arithmeticMean (x : float list) =

printfn "Arithmetic Mean: %A" (arithmeticMean P)

printfn "Geometric Mean: %A" (geometricMean P)

=={{header|Factor}}==

[ sum ] [ length ] bi / ;

: h-mean ( seq -- mean )

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

=={{header|Fantom}}==

class Main

{

}

}

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

' FB 1.05.0 Win64

Print "Press any key to quit the program"

Sleep

{{out}}

=={{header|FunL}}==

def

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

{{out}}

=={{header|Futhark}}==

fun arithmetic_mean(as: [n]f64): f64 =

reduce (+) 0.0 (map (/f64(n)) as)

geometric_mean as,

harmonic_mean as)

=={{header|GAP}}==

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

mean := v -> Sum(v) / Length(v);

# 3.41417

geomean(v);

=={{header|Go}}==

import (

fmt.Println("A:", a, "G:", g, "H:", h)

fmt.Println("A >= G >= H:", a >= g && g >= h)

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

list == null \

? null \

? 0 \

: list.size() / list.collect { 1.0/it }.sum()

Test:

def A = arithMean(list)

def G = geomMean(list)

G: ${G}

H: ${H}

{{out}}

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

let ms = zipWith ((. flip mean [1..10]). (,)) "agh" [1, 0, -1]

mapM_ (\(t,m) -> putStrLn $ t : ": " ++ show m) ms

====Three applicatively defined functions====

These three functions (each combining the length of a list with some kind of fold over the elements of that same list), all share the same applicative structure.

-- ARITHMETIC, GEOMETRIC AND HARMONIC MEANS ---------------

, mappend "\n A >= G >= H is " $ --

(show . and) $ zipWith (>=) xs (tail xs)

{{Out}}

<pre>("Arithmetic",5.5)("Geometric",4.528728688116765)("Harmonic",3.414171521474055)

=={{header|HicEst}}==

AGH = (0, 1, 0)

DO i = 1, 10

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

! A=5.5; G=4.528728688; H=3.414171521; Result = 1;

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

procedure main()

write(" a >= g >= h is ", if a >= g >= h then "true" else "false")

end

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn numbers:amean, numbers:gmean, and numbers:hmean] are shown below:

local m

if *L = 0 then fail

}

return *L / m

{{out}}

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

110 NUMERIC ARR(1 TO 10)

120 FOR I=LBOUND(ARR) TO UBOUND(ARR)

360 NEXT

370 LET HARMONIC=SIZE(A)/T

=={{header|J}}==

'''Solution:'''

gmean=: # %: */

'''Example Usage:'''

5.5 4.528729 3.414172

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

(and this variant should probably be preferred - especially if the argument list is long, to avoid problems with floating point infinity.)

=={{header|Java}}==

import java.util.List;

System.out.format("A >= G is %b, G >= H is %b%n", (arithmetic >= geometric), (geometric >= harmonic));

}

{{out}}

<pre>A = 5.500000 G = 4.528729 H = 3.414172

{{works with|Java|1.8}}

We can rewrite the 3 methods using the new JAVA Stream API:

public static double arithmAverage(double array[]){

if (array == null ||array.length == 0) {

}

}

=={{header|JavaScript}}==

===ES5===

'use strict';

})();

{{Out}}

"values": {

"Arithmetic": 5.5,

},

"test": "is A >= G >= H ? yes"

===ES6===

// arithmeticMean :: [Number] -> Number

mean.Geometric >= mean.Harmonic ? "yes" : "no"}`

}, 2);

{{Out}}

"values": {

"Arithmetic": 5.5,

},

"test": "is A >= G >= H ? yes"

=={{header|jq}}==

def logProduct: map(log) | add;

| ( $ans[],

"amean > gmean > hmean => \($ans[0] > $ans[1] and $ans[1] > $ans[2] )" )

{{Out}}

<pre>5.5

Julia has a `mean` function to compute the arithmetic mean of a collections

of numbers. We can redefine it as follows.

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

{{Out}}

<pre>julia> map(f-> f(1:10), [amean, gmean, hmean])

=={{header|K}}==

am:{(+/x)%#x}

gm:{(*/x)^(%#x)}

{(am x;gm x;hm x)} 1+!10

5.5 4.528729 3.414172

=={{header|Kotlin}}==

import kotlin.math.pow

println("A >= G is ${a >= g}, G >= H is ${g >= h}")

require(g in h..a)

{{out}}

<pre>A = 5.500000 G = 4.528729 H = 3.414172

=={{header|Lasso}}==

//sum of the list divided by its length

return (with e in #a sum #e) / decimal(#a->size)

arithmetic_mean(generateSeries(1,10)->asStaticArray)

geometric_mean(generateSeries(1,10)->asStaticArray)

{{out}}

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

a = a + i

next

print "False"

end if

=={{header|Logo}}==

local "sum

make "sum 0

print sentence [Geometric mean is] item 2 :means

print sentence [Harmonic mean is] item 3 :means

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

Module CheckIt {

sum=lambda -> {

}

CheckIt

=={{header|Maple}}==

Means := proc( x )

uses Statistics;

is( Arithmeticmean >= Geometricmean and Geometricmean >= Harmonicmean );

{{out}}

<pre>

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

{{out}}

<pre>{Arithmetic Mean, Geometric Mean, Harmonic Mean} = {5.5,4.52873,3.41417}</pre>

=={{header|MATLAB}}==

A = mean(list);

H = harmmean(list);

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

A = mean(list); % arithmetic mean

G = exp(mean(log(list))); % geometric mean

H = 1./mean(1./list); % harmonic mean

Solution:

A =

H =

=={{header|Maxima}}==

L: makelist(i, i, 1, 10)$

mean(L), numer; /* 5.5 */

geometric_mean(L), numer; /* 4.528728688116765 */

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

FROM FormatString IMPORT FormatString;

FROM LongMath IMPORT power;

ReadChar

=={{header|MUMPS}}==

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

;

Pythagorean means for 1..10:

=={{header|NetRexx}}==

{{trans|ooRexx}}

options replace format comments java crossref symbols nobinary

-- problem here...

return numbers.size / mean

{{out}}

<pre>

=={{header|Nim}}==

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

let numbers = toSeq(1..10).map((x: int) => float(x))

{{out}}

<pre>5.5 4.528728688116765 3.414171521474055</pre>

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

Oxford Oberon-2

MODULE PythMean;

IMPORT Out, ML := MathL;

END PythMean.

{{out}}

<pre>

=={{header|Objeck}}==

{{trans|Java}}

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

return numbers->Size() / mean;

}

Output:

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)

{{out}}

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

A = mean(list); % arithmetic mean

G = mean(list,'g'); % geometric mean

H = mean(list,'a'); % harmonic mean

See also Matlab implementation [[#MATLAB]]

=={{header|Oforth}}==

: A ( x )

"Arithmetic mean :" . 10 seq A dup . g >= ifTrue: [ " ==> A >= G" .cr ]

"Harmonic mean :" . 10 seq H dup . g <= ifTrue: [ " ==> G >= H" .cr ]

{{out}}

=={{header|ooRexx}}==

say "Arithmetic =" arithmeticMean(a)", Geometric =" geometricMean(a)", Harmonic =" harmonicMean(a)

return numbers~items / mean

{{out}}

<pre>Arithmetic = 5.5, Geometric = 4.52872869, Harmonic = 3.41417153</pre>

=={{header|Oz}}==

%% helpers

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

{Show [A G H]}

A >= G = true

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

General implementations:

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

};

v=vector(10,i,i);

Specific to the first ''n'' positive integers:

(n+1)/2

};

[arithmetic_first(10),geometric_first(10),harmonic_first(10)]

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

=={{header|Perl}}==

{

my $a = 0;

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

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">arithmetic_mean</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Harmonic: %.10g\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">harmonic</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Arithmetic&gt;=Geometric&gt;=Harmonic: %t\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">arithmetic</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">geometric</span> <span style="color: #008080;">and</span> <span style="color: #000000;">geometric</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">harmonic</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|PHP}}==

// Created with PHP 7.0

echo "Geometric: " . GeometricMean($values) . "\n";

echo "Harmonic: " . HarmonicMean($values) . "\n";

{{out}}

<pre>

=={{header|PicoLisp}}==

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

(format

(*/ (* 1.0 Len) 1.0 (sum '((N) (*/ 1.0 1.0 N)) Lst))

{{out}}

<pre>Arithmetic mean: 5.500000

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

Results:

<pre>

10 pythamean

{{out}}

{{libheader|initlib}}

/numbers {[1 10] 1 range}.

/recip {1 exch div}.

% Harmonic mean

numbers dup 0 {recip +} fold exch length exch div

=={{header|PowerShell}}==

$LogG = 0

$InvH = 0

write-host "Is A >= G ? $($A -ge $G)"

{{out}}

=={{header|Processing}}==

float[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

println("Arithmetic mean: " + arithmeticMean(numbers));

mean = nums.length / mean;

return mean;

{{out}}

<pre>Arithmetic mean: 5.5

=={{header|PureBasic}}==

For a = 1 To 10

mean + a

Debug ArithmeticMean()

Debug GeometricMean()

=={{header|Python}}==

{{works with|Python|3}}

from functools import reduce

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

print(a, g, h)

{{out}}

<pre>5.5 4.52872868812 3.41417152147</pre>

Uses <code>root</code> from [[Integer roots#Quackery]].

say "Arithmetic mean:" sp

[ 0 n->v rot

witheach [ n->v 1/v v+ ] ]

{{out}}

=={{header|R}}==

Initialise x

x <- 1:10

Arithmetic mean

a <- sum(x)/length(x)

or

a <- mean(x)

The geometric mean

g <- prod(x)^(1/length(x))

The harmonic mean (no error checking that <math>x_i\ne 0,\text{ } \forall \text{ }i=1\ldots n</math>)

h <- length(x)/sum(1/x)

Then:

a > g

and

g > h

give both

=={{header|Racket}}==

#lang racket

(harmonic xs)

(>= (arithmetic xs) (geometric xs) (harmonic xs))

{{out}}

<pre>

{{works with|Rakudo|2015.12}}

sub G { ([*] @_) ** (1 / @_) }

sub H { @_ / [+] 1 X/ @_ }

say "G(1,...,10) = ", G(1..10);

say "H(1,...,10) = ", H(1..10);

{{out}}

REXX doesn't have a &nbsp; '''POW''' &nbsp; function, so an &nbsp; '''IROOT''' &nbsp; ('''i'''nteger '''root''') &nbsp; function is included here; &nbsp; it includes an

<br>extra error check if used as a general purpose function that would otherwise yield a complex result.

numeric digits 20 /*use a little extra for the precision.*/

parse arg n . /*obtain the optional argument from CL.*/

g= g * sign(ox); if oy<0 then g= 1 / g /*adjust for original X sign; neg. root*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ring}}==

decimals(8)

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

next

return sum

Output:

<pre>

=={{header|Ruby}}==

{{works with|Ruby|1.9+}}