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)

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

{{libheader|Action! Tool Kit}}

PROC InverseI(INT a,result)

=={{header|ActionScript}}==

{

var sum:Number = 0;

pythagorean_means.ads:

type Set is array (Positive range <>) of Float;

function Arithmetic_Mean (Data : Set) return Float;

pythagorean_means.adb:

package body Pythagorean_Means is

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

example main.adb:

with Pythagorean_Means;

procedure Main is

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

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

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

Think about "talk" programming...

#include <hopper.h>

=={{header|APL}}==

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

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

=={{header|AppleScript}}==

{{trans|JavaScript}}

on arithmetic_mean(xs)

end mReturn</syntaxhighlight>

{{Out}}

inequalities:{|A >= G|:true}, |G >= H|:true}</syntaxhighlight>

=={{header|Arturo}}==

average arr

=={{header|AutoHotkey}}==

G := GeometricMean(1, 10)

H := HarmonicMean(1, 10)

=={{header|AWK}}==

{

x = $1; # value of 1st column

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

=={{header|C}}==

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

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

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

using System.Collections.Generic;

using System.Diagnostics;

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

#include <iostream>

#include <numeric>

=={{header|Clojure}}==

(defn a-mean [coll]

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

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

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

=={{header|D}}==

The output for the harmonic mean is wrong.

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

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

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

return def mean(numbers) {

var count := 0

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

# value: 5.5

=={{header|EchoLisp}}==

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

=={{header|Elixir}}==

def arithmetic(list) do

Enum.sum(list) / length(list)

=={{header|Erlang}}==

-module(mean_calculator).

=={{header|ERRE}}==

PROGRAM MEANS

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

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

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

Alternatively, e.g.,

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

</syntaxhighlight>

=={{header|Euphoria}}==

atom sum

if length(s) = 0 then

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)

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

let arithmeticMean (x : float list) =

=={{header|Factor}}==

[ sum ] [ length ] bi / ;

=={{header|Fantom}}==

class Main

{

=={{header|Forth}}==

0e

tuck floats bounds do

=={{header|Fortran}}==

{{works with|Fortran|90}}

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

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

=={{header|FunL}}==

def

=={{header|Futhark}}==

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

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

=={{header|GAP}}==

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

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

=={{header|Go}}==

import (

=={{header|Groovy}}==

Solution:

list == null \

? null \

Test:

def A = arithMean(list)

def G = geomMean(list)

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

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

=={{header|HicEst}}==

AGH = (0, 1, 0)

DO i = 1, 10

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

procedure main()

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

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

110 NUMERIC ARR(1 TO 10)

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

=={{header|J}}==

'''Solution:'''

gmean=: # %: */

hmean=: amean&.:%</syntaxhighlight>

'''Example Usage:'''

5.5 4.528729 3.414172

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

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;

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

===ES5===

'use strict';

{{Out}}

"values": {

"Arithmetic": 5.5,

===ES6===

// arithmeticMean :: [Number] -> Number

})();</syntaxhighlight>

{{Out}}

"values": {

"Arithmetic": 5.5,

=={{header|jq}}==

def logProduct: map(log) | add;

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

=={{header|K}}==

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

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

=={{header|Kotlin}}==

import kotlin.math.pow

=={{header|Lasso}}==

//sum of the list divided by its length

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

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

a = a + i

next

=={{header|Logo}}==

local "sum

make "sum 0

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

Module CheckIt {

sum=lambda -> {

=={{header|Maple}}==

Means := proc( x )

uses Statistics;

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

N@Through[{Mean, GeometricMean, HarmonicMean}[Range@10]]]</syntaxhighlight>

{{out}}

=={{header|MATLAB}}==

A = mean(list);

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

A = mean(list); % arithmetic mean

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

Solution:

A =

=={{header|Maxima}}==

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

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

FROM FormatString IMPORT FormatString;

FROM LongMath IMPORT power;

=={{header|MUMPS}}==

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

;

=={{header|NetRexx}}==

{{trans|ooRexx}}

options replace format comments java crossref symbols nobinary

=={{header|Nim}}==

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

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

Oxford Oberon-2

MODULE PythMean;

IMPORT Out, ML := MathL;

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

The three means in one function

let n = Array.length v

and a = ref 0.0

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

=={{header|Octave}}==

A = mean(list); % arithmetic mean

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

=={{header|Oforth}}==

: A ( x )

=={{header|ooRexx}}==

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

=={{header|Oz}}==

%% helpers

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

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

General implementations:

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

};

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

(n+1)/2

};

=={{header|Perl}}==

{

my $a = 0;

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

=={{header|PHP}}==

// Created with PHP 7.0

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

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

declare n fixed binary,

(Average, Geometric, Harmonic) float;

=={{header|PostScript}}==

/pythamean{

/x exch def

{{libheader|initlib}}

/numbers {[1 10] 1 range}.

/recip {1 exch div}.

=={{header|PowerShell}}==

$LogG = 0

$InvH = 0

=={{header|Processing}}==

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

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

=={{header|PureBasic}}==

For a = 1 To 10

mean + a

=={{header|Python}}==

{{works with|Python|3}}

from functools import reduce

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

say "Arithmetic mean:" sp

=={{header|R}}==

Initialise x

x <- 1:10

</syntaxhighlight>

Arithmetic mean

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

</syntaxhighlight>

or

a <- mean(x)

</syntaxhighlight>

The geometric mean

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

</syntaxhighlight>

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)

</syntaxhighlight>

Then:

a > g

</syntaxhighlight>

and

g > h

</syntaxhighlight>

=={{header|Racket}}==

#lang racket

{{works with|Rakudo|2015.12}}

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

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

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

=={{header|Ring}}==

decimals(8)

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

=={{header|Ruby}}==

{{works with|Ruby|1.9+}}

def arithmetic_mean

inject(0.0, :+) / length

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

for i = 1 to 10

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

=={{header|Rust}}==

let mut sum = 0.0;

let mut prod = 1;

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

=={{header|Scheme}}==

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

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

(newline))</syntaxhighlight>

{{out}}

#t</syntaxhighlight>

=={{header|Seed7}}==

include "float.s7i";

=={{header|Sidef}}==

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

func H(a) { a.len / a.map{1/_}.sum }</syntaxhighlight>

The same thing, using hyper-operators:

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

func H(a) { a.len / (a«/«1 «+») }</syntaxhighlight>

Calling the functions:

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

say("H(1,...,10) = ", H(1..10));</syntaxhighlight>

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

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

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

=={{header|Tcl}}==

set sum 0.0

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

=={{header|Ursala}}==

#import flo

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

double arithmetic(int[] list){

double mean;

=={{header|VBA}}==

Uses Excel VBA.

arithmetic_mean = WorksheetFunction.Average(s)

End Function

=={{header|VBScript}}==

Function arithmetic_mean(arr)

sum = 0

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

{{trans|C#}}

Module Module1

=={{header|Vlang}}==

Updated for Vlang version 0.2.2

fn main() {

=={{header|Wren}}==

var count = rng.count

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

=={{header|XPL0}}==

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

=={{header|zkl}}==

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

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

3.41417

</pre>