Averages/Pythagorean means: Difference between revisions

{{task}}

 

 

Compute all three of the [[wp:Pythagorean means|Pythagorean means]] of the set of integers <big>1</big> through <big>10</big> (inclusive).

 

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

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

print(amean(numbers))

print(gmean(numbers))

 

{{out}}

4.52873

3.41417

</pre>

 

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

Geometric mean: 4.52872

Harmonic mean: 3.41417

</pre>

 

=={{header|APL}}==

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

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

4.528728688

harmonic x

 

=={{header|AppleScript}}==

{{trans|JavaScript}}

on arithmetic_mean(xs)

end script

end if

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

Geometric mean = 4.52872869

Harmonic mean = 3.41417152</pre>

 

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

 

=={{header|ERRE}}==

PROGRAM MEANS

 

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

 

fun Collection<Double>.harmonicMean() =

if (isEmpty() || contains(0.0)) Double.NaN

 

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

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

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

 

=={{header|PostScript}}==

/pythamean{

/x exch def

 

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

Is A >= G ? True

Is G >= H ? True</pre>

 

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

 

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

 

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

say ' list ='$ /*display the list of numbers used. */

say 'Amean =' sum / n /*calculate & display arithmetic mean.*/

say 'Gmean =' Iroot(prod, n) /* " " " geometric " */

say 'Hmean =' n / rSum /* " " " harmonic " */

/*──────────────────────────────────────────────────────────────────────────────────────*/

 

<pre>

list = 1 2 3 4 5 6 7 8 9 10

 

=={{header|Ring}}==

decimals(8)

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

next

return sum

Output:

<pre>

geometric mean = 4.52872869

harmonic mean = 3.41417152

</pre>

 

=={{header|Ruby}}==

{{works with|Ruby|1.9+}}

def arithmetic_mean

inject(0.0, :+) / length

p h = (1..10).harmonic_mean

# is h < g < a ??

 

{{out}}

 

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

for i = 1 to 10

sum = sum + i ' sum of 1 -> 10

print " Harmonic Mean:";harmonic

{{out}}

<pre>

 

=={{header|Rust}}==

let mut sum = 0.0;

let mut prod = 1;

 

}

{{out}}

<pre>

=={{header|Scala}}==

{{works with|Scala|2.8+}}

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

println("Harmonic mean " + h)

 

{{out}}

<pre>Arithmetic mean 5.5

=={{header|Scheme}}==

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

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

 

(newline)

(display (>= a g h))

{{out}}

 

=={{header|Seed7}}==

include "float.s7i";

 

writeln("Geometric mean: " <& product ** (1.0 / flt(length(numbers))));

writeln("Harmonic mean: " <& flt(length(numbers)) / reciprocalSum);

 

{{out}}

 

=={{header|Sidef}}==

func G(a) { a.prod.root(a.len) }

 

The same thing, using hyper-operators:

func G(a) { a«*» ** (1/a.len) }

 

Calling the functions:

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

{{out}}

<pre>A(1,...,10) = 5.5

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

 

[

arithmeticMean

 

((a arithmeticMean) >= (a geometricMean)) displayNl.

 

{{out}}

=={{header|SQL}}==

It may not be possible to calculate a geometric mean in a query, but the other two are easy enough.

--setup

create table averages (val integer);

from

averages;

{{out}}

<pre>

=={{header|Stata}}==

The command [http://www.stata.com/help.cgi?ameans ameans] prints the arithmetic, geometric and harmonic means, together with confidence intervals.

set obs 10

gen x=_n

| Geometric 10 4.528729 2.680672 7.650836

| Harmonic 10 3.414172 2.035664 10.57602

 

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

 

{{out}}

=={{header|Ursala}}==

 

#import flo

 

#cast %eLbX

 

{{out}}

<pre>(

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

 

double arithmetic(int[] list){

double mean;

stdout.printf("Harmonic mean: %s\n", harmonic_mean.to_string());

}

 

{{out}}

=={{header|VBA}}==

Uses Excel VBA.

arithmetic_mean = WorksheetFunction.Average(s)

End Function

Debug.Print "G ="; geometric_mean(s)

Debug.Print "H ="; harmonic_mean(s)

<pre>A = 5,5

G = 4,52872868811677

 

=={{header|VBScript}}==

Function arithmetic_mean(arr)

sum = 0

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

 

{{Out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>Arithmetic mean 5.5

Harmonic mean 3.41417152147406</pre>

 

 

fn main() {

mut prod :=1.0

mut recip_sum := 0.0

sum += val

prod *= val

}

a := sum / n

h := n / recip_sum

{{out}}

<pre>Arithmetic Mean: 5.50

 

=={{header|Wren}}==

var count = rng.count

var A = rng.reduce { |acc, x| acc + x }/count

System.print(" Geometric mean = %(G)")

System.print(" Harmonic mean = %(H)")

 

{{out}}

 

=={{header|XPL0}}==

 

func real Power(X, Y); \X raised to the Y power

Text(0, "ALWAYS DECREASING ORDER

");

 

{{out}}

 

=={{header|zkl}}==

ns.sum(0.0)/ns.len(); // Arithmetic mean

ns.reduce('*,1.0).pow(1.0/ns.len()); // Geometric mean

{{out}}

<pre>

3.41417

</pre>