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>