Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
4
Task/Averages-Pythagorean-means/00-META.yaml
Normal file
4
Task/Averages-Pythagorean-means/00-META.yaml
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
---
|
||||
category:
|
||||
- Geometry
|
||||
from: http://rosettacode.org/wiki/Averages/Pythagorean_means
|
||||
23
Task/Averages-Pythagorean-means/00-TASK.txt
Normal file
23
Task/Averages-Pythagorean-means/00-TASK.txt
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
;Task
|
||||
|
||||
Compute all three of the [[wp:Pythagorean means|Pythagorean means]] of the set of integers <big>1</big> through <big>10</big> (inclusive).
|
||||
|
||||
Show that <big><math>A(x_1,\ldots,x_n) \geq G(x_1,\ldots,x_n) \geq H(x_1,\ldots,x_n)</math></big> for this set of positive integers.
|
||||
|
||||
* The most common of the three means, the [[Averages/Arithmetic mean|arithmetic mean]], is the sum of the list divided by its length:
|
||||
: <big><math> A(x_1, \ldots, x_n) = \frac{x_1 + \cdots + x_n}{n}</math></big>
|
||||
|
||||
* The [[wp:Geometric mean|geometric mean]] is the <math>n</math>th root of the product of the list:
|
||||
: <big><math> G(x_1, \ldots, x_n) = \sqrt[n]{x_1 \cdots x_n} </math></big>
|
||||
|
||||
* The [[wp:Harmonic mean|harmonic mean]] is <math>n</math> divided by the sum of the reciprocal of each item in the list:
|
||||
: <big><math> H(x_1, \ldots, x_n) = \frac{n}{\frac{1}{x_1} + \cdots + \frac{1}{x_n}} </math></big>
|
||||
|
||||
|
||||
|
||||
{{task heading|See also}}
|
||||
|
||||
{{Related tasks/Statistical measures}}
|
||||
|
||||
<br><hr>
|
||||
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
F amean(num)
|
||||
R sum(num)/Float(num.len)
|
||||
|
||||
F gmean(num)
|
||||
R product(num) ^ (1.0/num.len)
|
||||
|
||||
F hmean(num)
|
||||
return num.len / sum(num.map(n -> 1.0/n))
|
||||
|
||||
V numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
print(amean(numbers))
|
||||
print(gmean(numbers))
|
||||
print(hmean(numbers))
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
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))
|
||||
)
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
begin
|
||||
% returns the arithmetic mean of the elements of n from lo to hi %
|
||||
real procedure arithmeticMean ( real array n ( * ); integer value lo, hi ) ;
|
||||
begin
|
||||
real sum;
|
||||
sum := 0;
|
||||
for i := lo until hi do sum := sum + n( i );
|
||||
sum / ( 1 + ( hi - lo ) )
|
||||
end arithmeticMean ;
|
||||
% returns the geometric mean of the elements of n from lo to hi %
|
||||
real procedure geometricMean ( real array n ( * ); integer value lo, hi ) ;
|
||||
begin
|
||||
real product;
|
||||
product := 1;
|
||||
for i := lo until hi do product := product * n( i );
|
||||
exp( ln( product ) / ( 1 + ( hi - lo ) ) )
|
||||
end geometricMean ;
|
||||
% returns the harminic mean of the elements of n from lo to hi %
|
||||
real procedure harmonicMean ( real array n ( * ); integer value lo, hi ) ;
|
||||
begin
|
||||
real sum;
|
||||
sum := 0;
|
||||
for i := lo until hi do sum := sum + ( 1 / n( i ) );
|
||||
( 1 + ( hi - lo ) ) / sum
|
||||
end harmonicMean ;
|
||||
|
||||
real array v ( 1 :: 10 );
|
||||
for i := 1 until 10 do v( i ) := i;
|
||||
|
||||
r_w := 10; r_d := 5; r_format := "A"; s_w := 0; % set output format %
|
||||
|
||||
write( "Arithmetic mean: ", arithmeticMean( v, 1, 10 ) );
|
||||
write( "Geometric mean: ", geometricMean( v, 1, 10 ) );
|
||||
write( "Harmonic mean: ", harmonicMean( v, 1, 10 ) )
|
||||
|
||||
end.
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
arithmetic←{(+/⍵)÷⍴⍵}
|
||||
geometric←{(×/⍵)*÷⍴⍵}
|
||||
harmonic←{(⍴⍵)÷(+/÷⍵)}
|
||||
|
||||
|
||||
x←⍳10
|
||||
|
||||
arithmetic x
|
||||
5.5
|
||||
geometric x
|
||||
4.528728688
|
||||
harmonic x
|
||||
3.414171521
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#!/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;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
|
||||
|
||||
PROC InverseI(INT a,result)
|
||||
REAL one,x
|
||||
|
||||
IntToReal(1,one)
|
||||
IntToReal(a,x)
|
||||
RealDiv(one,x,result)
|
||||
RETURN
|
||||
|
||||
PROC ArithmeticMean(INT ARRAY a INT count REAL POINTER result)
|
||||
INT i
|
||||
REAL x,sum,tmp
|
||||
|
||||
IntToReal(0,sum)
|
||||
FOR i=0 TO count-1
|
||||
DO
|
||||
IntToReal(a(i),x)
|
||||
RealAdd(sum,x,tmp)
|
||||
RealAssign(tmp,sum)
|
||||
OD
|
||||
IntToReal(count,tmp)
|
||||
RealDiv(sum,tmp,result)
|
||||
RETURN
|
||||
|
||||
PROC GeometricMean(INT ARRAY a INT count REAL POINTER result)
|
||||
INT i
|
||||
REAL x,prod,tmp
|
||||
|
||||
IntToReal(1,prod)
|
||||
FOR i=0 TO count-1
|
||||
DO
|
||||
IntToReal(a(i),x)
|
||||
RealMult(prod,x,tmp)
|
||||
RealAssign(tmp,prod)
|
||||
OD
|
||||
InverseI(count,tmp)
|
||||
Power(prod,tmp,result)
|
||||
RETURN
|
||||
|
||||
PROC HarmonicMean(INT ARRAY a INT count REAL POINTER result)
|
||||
INT i
|
||||
REAL x,sum,tmp
|
||||
|
||||
IntToReal(0,sum)
|
||||
FOR i=0 TO count-1
|
||||
DO
|
||||
InverseI(a(i),x)
|
||||
RealAdd(sum,x,tmp)
|
||||
RealAssign(tmp,sum)
|
||||
OD
|
||||
IntToReal(count,tmp)
|
||||
RealDiv(tmp,sum,result)
|
||||
RETURN
|
||||
|
||||
PROC Main()
|
||||
BYTE i
|
||||
INT ARRAY a=[1 2 3 4 5 6 7 8 9 10]
|
||||
REAL result
|
||||
|
||||
Put(125) PutE() ;clear screen
|
||||
|
||||
ArithmeticMean(a,10,result)
|
||||
Print("Arithmetic mean=") PrintRE(result)
|
||||
GeometricMean(a,10,result)
|
||||
Print(" Geometric mean=") PrintRE(result)
|
||||
HarmonicMean(a,10,result)
|
||||
Print(" Harmonic mean=") PrintRE(result)
|
||||
RETURN
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
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));
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <hopper.h>
|
||||
|
||||
/* An example of definitions in pseudo-natural language, with synonimous.
|
||||
These definitions can be inside a definition file (xxxx.h) */
|
||||
#define getasinglelistof(_X_) {_X_},
|
||||
#synon getasinglelistof getalistof
|
||||
#define integerrandomnumbers _V1000_=-1,rand array(_V1000_),mulby(10),ceil,
|
||||
#define randomnumbers _V1000_=-1,rand array(_V1000_)
|
||||
#define rememberitin(_X_) _X_=0,cpy(_X_)
|
||||
#synon rememberitin rememberthisnumbersin
|
||||
#define rememberas(_X_) mov(_X_)
|
||||
#define remember(_X_) {_X_}
|
||||
//#synon remember with ---> this exist in HOPPER.H
|
||||
#defn nowconsiderthis(_X_) #ATOM#CMPLX,print
|
||||
#synon nowconsiderthis nowconsider,considerthis,consider,nowputtext,puttext,andprint
|
||||
#define andprintwithanewline {"\n"}print
|
||||
#synon andprintwithanewline printwithanewline
|
||||
//#defn andprint(_X_) #ATOM#CMPLX,print
|
||||
#define putanewline {"\n"}
|
||||
#define withanewline "\n"
|
||||
#define andprintit print
|
||||
#synon andprintit printit,andprint
|
||||
#define showit show
|
||||
#define afterdoingit emptystack?,not,do{ {"I cannot continue due to retentive data "},throw(1001) }
|
||||
#synon afterdoingit secondly,finally
|
||||
#define then emptystack?do{ {"I cannot continue because data is missing "},throw(1000) }
|
||||
/* why "#context" and not "#define"?
|
||||
becose "#context" need a value in the stack for continue.
|
||||
Internally, "domeanit" tranform to "gosub(calculatearithmeticmean)",
|
||||
and "gosub" works only if it finds a data in the stack */
|
||||
#context calculatethegeometricmean
|
||||
#synon calculatethegeometricmean calculategeometricmean,getgeometricmean
|
||||
#context calculatetheharmonicmean
|
||||
#synon calculatetheharmonicmean calculateharmonicmean,getharmonicmean
|
||||
#context calculatearitmethicmean
|
||||
#synon calculatearitmethicmean calculatesinglemean,calculatemean,domeanit
|
||||
|
||||
main:
|
||||
consider this ("Arithmetic Mean: ")
|
||||
get a list of '10,10' integer random numbers; remember this numbers in 'list of numbers';
|
||||
then, do mean it, and print with a new line.
|
||||
after doing it, consider ("Geometric Mean: "), remember 'list of numbers', calculate the geometric mean;
|
||||
then, put a new line, and print it.
|
||||
/*
|
||||
Okay. This can be a bit long, if we have to write the program;
|
||||
But what if we just had to talk, and the language interpreter takes care of the rest?
|
||||
*/
|
||||
secondly, now consider ("Harmonic Mean: "), with 'list of numbers', get harmonic mean, and print with a new line.
|
||||
finally, put text ("Original Array:\n"), and print (list of numbers, with a new line)
|
||||
exit(0)
|
||||
.locals
|
||||
calculate aritmethic mean:
|
||||
stats(MEAN)
|
||||
back
|
||||
calculate the geometric mean:
|
||||
stats(GEOMEAN)
|
||||
back
|
||||
calculatetheharmonicmean:
|
||||
stats(HARMEAN)
|
||||
back
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
-- arithmetic_mean :: [Number] -> Number
|
||||
on arithmetic_mean(xs)
|
||||
|
||||
-- sum :: Number -> Number -> Number
|
||||
script sum
|
||||
on |λ|(accumulator, x)
|
||||
accumulator + x
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
foldl(sum, 0, xs) / (length of xs)
|
||||
end arithmetic_mean
|
||||
|
||||
-- geometric_mean :: [Number] -> Number
|
||||
on geometric_mean(xs)
|
||||
|
||||
-- product :: Number -> Number -> Number
|
||||
script product
|
||||
on |λ|(accumulator, x)
|
||||
accumulator * x
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
foldl(product, 1, xs) ^ (1 / (length of xs))
|
||||
end geometric_mean
|
||||
|
||||
-- harmonic_mean :: [Number] -> Number
|
||||
on harmonic_mean(xs)
|
||||
|
||||
-- addInverse :: Number -> Number -> Number
|
||||
script addInverse
|
||||
on |λ|(accumulator, x)
|
||||
accumulator + (1 / x)
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
(length of xs) / (foldl(addInverse, 0, xs))
|
||||
end harmonic_mean
|
||||
|
||||
-- TEST -----------------------------------------------------------------------
|
||||
on run
|
||||
set {A, G, H} to ap({arithmetic_mean, geometric_mean, harmonic_mean}, ¬
|
||||
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}})
|
||||
|
||||
{values:{arithmetic:A, geometric:G, harmonic:H}, inequalities:¬
|
||||
{|A >= G|:A ≥ G}, |G >= H|:G ≥ H}
|
||||
end run
|
||||
|
||||
|
||||
-- GENERIC FUNCTIONS ----------------------------------------------------------
|
||||
|
||||
-- A list of functions applied to a list of arguments
|
||||
-- (<*> | ap) :: [(a -> b)] -> [a] -> [b]
|
||||
on ap(fs, xs)
|
||||
set {nf, nx} to {length of fs, length of xs}
|
||||
set acc to {}
|
||||
repeat with i from 1 to nf
|
||||
tell mReturn(item i of fs)
|
||||
repeat with j from 1 to nx
|
||||
set end of acc to |λ|(contents of (item j of xs))
|
||||
end repeat
|
||||
end tell
|
||||
end repeat
|
||||
return acc
|
||||
end ap
|
||||
|
||||
-- foldl :: (a -> b -> a) -> a -> [b] -> a
|
||||
on foldl(f, startValue, xs)
|
||||
tell mReturn(f)
|
||||
set v to startValue
|
||||
set lng to length of xs
|
||||
repeat with i from 1 to lng
|
||||
set v to |λ|(v, item i of xs, i, xs)
|
||||
end repeat
|
||||
return v
|
||||
end tell
|
||||
end foldl
|
||||
|
||||
-- map :: (a -> b) -> [a] -> [b]
|
||||
on map(f, xs)
|
||||
tell mReturn(f)
|
||||
set lng to length of xs
|
||||
set lst to {}
|
||||
repeat with i from 1 to lng
|
||||
set end of lst to |λ|(item i of xs, i, xs)
|
||||
end repeat
|
||||
return lst
|
||||
end tell
|
||||
end map
|
||||
|
||||
-- Lift 2nd class handler function into 1st class script wrapper
|
||||
-- mReturn :: Handler -> Script
|
||||
on mReturn(f)
|
||||
if class of f is script then
|
||||
f
|
||||
else
|
||||
script
|
||||
property |λ| : f
|
||||
end script
|
||||
end if
|
||||
end mReturn
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
{values:{arithmetic:5.5, geometric:4.528728688117, harmonic:3.414171521474},
|
||||
inequalities:{|A >= G|:true}, |G >= H|:true}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
arithmeticMean: function [arr]->
|
||||
average arr
|
||||
|
||||
geometricMean: function [arr]->
|
||||
(product arr) ^ 1//size arr
|
||||
|
||||
harmonicMean: function [arr]->
|
||||
(size arr) // sum map arr 'i [1//i]
|
||||
|
||||
print arithmeticMean 1..10
|
||||
print geometricMean 1..10
|
||||
print harmonicMean 1..10
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
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
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
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())
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <numeric>
|
||||
#include <cmath>
|
||||
#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 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
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.0 / i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h> // atoi()
|
||||
#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;
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
(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))
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
(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)))
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
precision 6
|
||||
|
||||
define bxsum = 1, sum = 0, sum1i = 0
|
||||
define average = 0, geometric = 0, harmonic = 0
|
||||
|
||||
for i = 1 to 10
|
||||
|
||||
let sum = sum + i
|
||||
let bxsum = bxsum * i
|
||||
let sum1i = sum1i + (1 / i)
|
||||
|
||||
next i
|
||||
|
||||
let average = sum / 10
|
||||
let geometric = bxsum ^ (1 / 10)
|
||||
let harmonic = 10 / sum1i
|
||||
|
||||
print "arithmetic mean: ", average
|
||||
print "geometric mean: ", geometric
|
||||
print "harmonic mean: ", harmonic
|
||||
|
||||
if average >= geometric and geometric >= harmonic then
|
||||
|
||||
print "true"
|
||||
end
|
||||
|
||||
endif
|
||||
|
||||
print "false"
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
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);
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
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 })
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
? A(1..10)
|
||||
# value: 5.5
|
||||
|
||||
? G(1..10)
|
||||
# value: 4.528728688116765
|
||||
|
||||
? H(1..10)
|
||||
# value: 3.414171521474055
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
(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
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
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}"
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
%% 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).
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
>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
|
||||
|
|
@ -0,0 +1 @@
|
|||
>function G(x) := prod(x)^(1/length(x))
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
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)})
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
=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)
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
: a-mean ( seq -- mean )
|
||||
[ sum ] [ length ] bi / ;
|
||||
|
||||
: g-mean ( seq -- mean )
|
||||
[ product ] [ length recip ] bi ^ ;
|
||||
|
||||
: h-mean ( seq -- mean )
|
||||
[ length ] [ [ recip ] map-sum ] bi / ;
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
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")
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
: 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
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
' FB 1.05.0 Win64
|
||||
|
||||
Function ArithmeticMean(array() As Double) As Double
|
||||
Dim length As Integer = Ubound(array) - Lbound(array) + 1
|
||||
Dim As Double sum = 0.0
|
||||
For i As Integer = LBound(array) To UBound(array)
|
||||
sum += array(i)
|
||||
Next
|
||||
Return sum/length
|
||||
End Function
|
||||
|
||||
Function GeometricMean(array() As Double) As Double
|
||||
Dim length As Integer = Ubound(array) - Lbound(array) + 1
|
||||
Dim As Double product = 1.0
|
||||
For i As Integer = LBound(array) To UBound(array)
|
||||
product *= array(i)
|
||||
Next
|
||||
Return product ^ (1.0 / length)
|
||||
End Function
|
||||
|
||||
Function HarmonicMean(array() As Double) As Double
|
||||
Dim length As Integer = Ubound(array) - Lbound(array) + 1
|
||||
Dim As Double sum = 0.0
|
||||
For i As Integer = LBound(array) To UBound(array)
|
||||
sum += 1.0 / array(i)
|
||||
Next
|
||||
Return length / sum
|
||||
End Function
|
||||
|
||||
Dim vector(1 To 10) As Double
|
||||
For i As Integer = 1 To 10
|
||||
vector(i) = i
|
||||
Next
|
||||
|
||||
Print "Arithmetic mean is :"; ArithmeticMean(vector())
|
||||
Print "Geometric mean is :"; GeometricMean(vector())
|
||||
Print "Harmonic mean is :"; HarmonicMean(vector())
|
||||
Print
|
||||
Print "Press any key to quit the program"
|
||||
Sleep
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
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, (>=)) )
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
fun arithmetic_mean(as: [n]f64): f64 =
|
||||
reduce (+) 0.0 (map (/f64(n)) as)
|
||||
|
||||
fun geometric_mean(as: [n]f64): f64 =
|
||||
reduce (*) 1.0 (map (**(1.0/f64(n))) as)
|
||||
|
||||
fun harmonic_mean(as: [n]f64): f64 =
|
||||
f64(n) / reduce (+) 0.0 (map (1.0/) as)
|
||||
|
||||
fun main(as: [n]f64): (f64,f64,f64) =
|
||||
(arithmetic_mean as,
|
||||
geometric_mean as,
|
||||
harmonic_mean as)
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
# The first two work with rationals or with floats
|
||||
# (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]);
|
||||
# 11/2
|
||||
harmean([1 .. 10]);
|
||||
# 25200/7381
|
||||
|
||||
v := List([1..10], FLOAT_INT);;
|
||||
mean(v);
|
||||
# 5.5
|
||||
harmean(v);
|
||||
# 3.41417
|
||||
geomean(v);
|
||||
# 4.52873
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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)
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
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()
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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}
|
||||
"""
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
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))
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
import Data.List (genericLength)
|
||||
|
||||
-- ARITHMETIC, GEOMETRIC AND HARMONIC MEANS ---------------
|
||||
arithmetic, geometric, harmonic :: [Double] -> Double
|
||||
arithmetic = (/) . sum <*> genericLength
|
||||
|
||||
geometric = (**) . product <*> ((1 /) . genericLength)
|
||||
|
||||
harmonic = (/) . genericLength <*> foldr ((+) . (1 /)) 0
|
||||
|
||||
-- TEST ---------------------------------------------------
|
||||
xs :: [Double]
|
||||
xs = [arithmetic, geometric, harmonic] <*> [[1 .. 10]]
|
||||
|
||||
main :: IO ()
|
||||
main =
|
||||
(putStrLn . unlines)
|
||||
[ zip ["Arithmetic", "Geometric", "Harmonic"] xs >>= show
|
||||
, mappend "\n A >= G >= H is " $ --
|
||||
(show . and) $ zipWith (>=) xs (tail xs)
|
||||
]
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
100 PROGRAM "Averages.bas"
|
||||
110 NUMERIC ARR(1 TO 10)
|
||||
120 FOR I=LBOUND(ARR) TO UBOUND(ARR)
|
||||
130 LET ARR(I)=I
|
||||
140 NEXT
|
||||
150 PRINT "Arithmetic mean =";ARITHM(ARR)
|
||||
160 PRINT "Geometric mean =";GEOMETRIC(ARR)
|
||||
170 PRINT "Harmonic mean =";HARMONIC(ARR)
|
||||
180 DEF ARITHM(REF A)
|
||||
190 LET T=0
|
||||
200 FOR I=LBOUND(A) TO UBOUND(A)
|
||||
210 LET T=T+A(I)
|
||||
220 NEXT
|
||||
230 LET ARITHM=T/SIZE(A)
|
||||
240 END DEF
|
||||
250 DEF GEOMETRIC(REF A)
|
||||
260 LET T=1
|
||||
270 FOR I=LBOUND(A) TO UBOUND(A)
|
||||
280 LET T=T*A(I)
|
||||
290 NEXT
|
||||
300 LET GEOMETRIC=T^(1/SIZE(A))
|
||||
310 END DEF
|
||||
320 DEF HARMONIC(REF A)
|
||||
330 LET T=0
|
||||
340 FOR I=LBOUND(A) TO UBOUND(A)
|
||||
350 LET T=T+(1/A(I))
|
||||
360 NEXT
|
||||
370 LET HARMONIC=SIZE(A)/T
|
||||
380 END DEF
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
amean=: +/ % #
|
||||
gmean=: # %: */
|
||||
hmean=: amean&.:%
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
(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
|
||||
|
|
@ -0,0 +1 @@
|
|||
gmean=:amean&.:^.
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
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));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
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 ;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
(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);
|
||||
|
||||
})();
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
{
|
||||
"values": {
|
||||
"Arithmetic": 5.5,
|
||||
"Geometric": 4.528728688116765,
|
||||
"Harmonic": 3.414171521474055
|
||||
},
|
||||
"test": "is A >= G >= H ? yes"
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
(() => {
|
||||
|
||||
// arithmeticMean :: [Number] -> Number
|
||||
const arithmeticMean = xs =>
|
||||
foldl((sum, n) => sum + n, 0, xs) / length(xs);
|
||||
|
||||
// geometricMean :: [Number] -> Number
|
||||
const geometricMean = xs =>
|
||||
raise(foldl((product, x) => product * x, 1, xs), 1 / length(xs));
|
||||
|
||||
// harmonicMean :: [Number] -> Number
|
||||
const harmonicMean = xs =>
|
||||
length(xs) / foldl((invSum, n) => invSum + (1 / n), 0, xs);
|
||||
|
||||
// GENERIC FUNCTIONS ------------------------------------------------------
|
||||
|
||||
// A list of functions applied to a list of arguments
|
||||
// <*> :: [(a -> b)] -> [a] -> [b]
|
||||
const ap = (fs, xs) => //
|
||||
[].concat.apply([], fs.map(f => //
|
||||
[].concat.apply([], xs.map(x => [f(x)]))));
|
||||
|
||||
// foldl :: (b -> a -> b) -> b -> [a] -> b
|
||||
const foldl = (f, a, xs) => xs.reduce(f, a);
|
||||
|
||||
// length :: [a] -> Int
|
||||
const length = xs => xs.length;
|
||||
|
||||
// mapFromList :: [(k, v)] -> Dictionary
|
||||
const mapFromList = kvs =>
|
||||
foldl((a, [k, v]) =>
|
||||
(a[(typeof k === 'string' && k) || show(k)] = v, a), {}, kvs);
|
||||
|
||||
// raise :: Num -> Int -> Num
|
||||
const raise = (n, e) => Math.pow(n, e);
|
||||
|
||||
// show :: a -> String
|
||||
// show :: a -> Int -> String
|
||||
const show = (...x) =>
|
||||
JSON.stringify.apply(
|
||||
null, x.length > 1 ? [x[0], null, x[1]] : x
|
||||
);
|
||||
|
||||
// zip :: [a] -> [b] -> [(a,b)]
|
||||
const zip = (xs, ys) =>
|
||||
xs.slice(0, Math.min(xs.length, ys.length))
|
||||
.map((x, i) => [x, ys[i]]);
|
||||
|
||||
// TEST -------------------------------------------------------------------
|
||||
// mean :: Dictionary
|
||||
const mean = mapFromList(zip(
|
||||
['Arithmetic', 'Geometric', 'Harmonic'],
|
||||
ap([arithmeticMean, geometricMean, harmonicMean], [
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
])
|
||||
));
|
||||
|
||||
return show({
|
||||
values: mean,
|
||||
test: `is A >= G >= H ? ${mean.Arithmetic >= mean.Geometric &&
|
||||
mean.Geometric >= mean.Harmonic ? "yes" : "no"}`
|
||||
}, 2);
|
||||
})();
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
{
|
||||
"values": {
|
||||
"Arithmetic": 5.5,
|
||||
"Geometric": 4.528728688116765,
|
||||
"Harmonic": 3.414171521474055
|
||||
},
|
||||
"test": "is A >= G >= H ? yes"
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
def amean: add/length;
|
||||
|
||||
def logProduct: map(log) | add;
|
||||
|
||||
def gmean: (logProduct / length) | exp;
|
||||
|
||||
def hmean: length / (map(1/.) | add);
|
||||
|
||||
# Tasks:
|
||||
[range(1;11) ] | [amean, gmean, hmean] as $ans
|
||||
| ( $ans[],
|
||||
"amean > gmean > hmean => \($ans[0] > $ans[1] and $ans[1] > $ans[2] )" )
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
amean(A) = sum(A)/length(A)
|
||||
|
||||
gmean(A) = prod(A)^(1/length(A))
|
||||
|
||||
hmean(A) = length(A)/sum(1./A)
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
am:{(+/x)%#x}
|
||||
gm:{(*/x)^(%#x)}
|
||||
hm:{(#x)%+/%:'x}
|
||||
|
||||
{(am x;gm x;hm x)} 1+!10
|
||||
5.5 4.528729 3.414172
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
import kotlin.math.round
|
||||
import kotlin.math.pow
|
||||
|
||||
fun Collection<Double>.geometricMean() =
|
||||
if (isEmpty()) Double.NaN
|
||||
else (reduce { n1, n2 -> n1 * n2 }).pow(1.0 / size)
|
||||
|
||||
fun Collection<Double>.harmonicMean() =
|
||||
if (isEmpty() || contains(0.0)) Double.NaN
|
||||
else size / fold(0.0) { n1, n2 -> n1 + 1.0 / n2 }
|
||||
|
||||
fun Double.toFixed(len: Int = 6) =
|
||||
round(this * 10.0.pow(len)) / 10.0.pow(len)
|
||||
|
||||
fun main() {
|
||||
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 = $a G = ${g.toFixed()} H = ${h.toFixed()}")
|
||||
println("A >= G is ${a >= g}, G >= H is ${g >= h}")
|
||||
require(g in h..a)
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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)
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
Module CheckIt {
|
||||
sum=lambda -> {
|
||||
Read m as array
|
||||
if len(m)=0 then =0 : exit
|
||||
sum=Array(m, Dimension(m,0))
|
||||
If len(m)=1 then =sum : exit
|
||||
k=each(m,2,-1)
|
||||
While k {
|
||||
sum+=Array(k)
|
||||
}
|
||||
=sum
|
||||
}
|
||||
mean=lambda sum (a as array) ->{
|
||||
=sum(a)/len(a)
|
||||
}
|
||||
prod=lambda -> {
|
||||
m=array
|
||||
if len(m)=0 then =0 : exit
|
||||
prod=Array(m, Dimension(m,0))
|
||||
If len(m)=1 then =prod : exit
|
||||
k=each(m,2,-1)
|
||||
While k {
|
||||
prod*=Array(k)
|
||||
}
|
||||
=prod
|
||||
}
|
||||
geomean=lambda prod (a as array) -> {
|
||||
=prod(a)^(1/len(a))
|
||||
}
|
||||
harmomean=lambda (a as array) -> {
|
||||
if len(a)=0 then =0 : exit
|
||||
sum=1/Array(a, Dimension(a,0))
|
||||
If len(a)=1 then =1/sum : exit
|
||||
k=each(a,2,-1)
|
||||
While k {
|
||||
sum+=1/Array(k)
|
||||
}
|
||||
=len(a)/sum
|
||||
}
|
||||
Print sum((1,2,3,4,5))=15
|
||||
Print prod((1,2,3,4,5))=120
|
||||
Print mean((1,2,3,4,5))==3
|
||||
\\ use == to apply rounding before comparison
|
||||
Print geomean((1,2,3,4,5))==2.60517108469735
|
||||
Print harmomean((1,2,3,4,5))==2.18978102189784
|
||||
Generator =lambda x=1 ->{=x : x++}
|
||||
dim a(10)<<Generator()
|
||||
Print mean(a())==5.5
|
||||
Print geomean(a())==4.52872868811677
|
||||
Print harmomean(a())==3.41417152147412
|
||||
}
|
||||
CheckIt
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
function [A,G,H] = pythagoreanMeans(list)
|
||||
|
||||
A = mean(list);
|
||||
G = geomean(list);
|
||||
H = harmmean(list);
|
||||
|
||||
end
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
>> [A,G,H]=pythagoreanMeans((1:10))
|
||||
|
||||
A =
|
||||
|
||||
5.500000000000000
|
||||
|
||||
|
||||
G =
|
||||
|
||||
4.528728688116765
|
||||
|
||||
|
||||
H =
|
||||
|
||||
3.414171521474055
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
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 );
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
Print["{Arithmetic Mean, Geometric Mean, Harmonic Mean} = ",
|
||||
N@Through[{Mean, GeometricMean, HarmonicMean}[Range@10]]]
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
/* 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 */
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
'avg ^A
|
||||
(dup product 1 rolldown size / pow) ^G
|
||||
('size keep (1 swap /) (+) map-reduce /) ^H
|
||||
|
||||
(((1 10)) range (((A) (G) (H))) cleave) => (puts!) foreach
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
MODULE PythagoreanMeans;
|
||||
FROM FormatString IMPORT FormatString;
|
||||
FROM LongMath IMPORT power;
|
||||
FROM LongStr IMPORT RealToStr;
|
||||
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
|
||||
|
||||
PROCEDURE ArithmeticMean(numbers : ARRAY OF LONGREAL) : LONGREAL;
|
||||
VAR
|
||||
i,cnt : CARDINAL;
|
||||
mean : LONGREAL;
|
||||
BEGIN
|
||||
mean := 0.0;
|
||||
cnt := 0;
|
||||
FOR i:=0 TO HIGH(numbers) DO
|
||||
mean := mean + numbers[i];
|
||||
INC(cnt);
|
||||
END;
|
||||
RETURN mean / LFLOAT(cnt)
|
||||
END ArithmeticMean;
|
||||
|
||||
PROCEDURE GeometricMean(numbers : ARRAY OF LONGREAL) : LONGREAL;
|
||||
VAR
|
||||
i,cnt : CARDINAL;
|
||||
mean : LONGREAL;
|
||||
BEGIN
|
||||
mean := 1.0;
|
||||
cnt := 0;
|
||||
FOR i:=0 TO HIGH(numbers) DO
|
||||
mean := mean * numbers[i];
|
||||
INC(cnt);
|
||||
END;
|
||||
RETURN power(mean, 1.0 / LFLOAT(cnt))
|
||||
END GeometricMean;
|
||||
|
||||
PROCEDURE HarmonicMean(numbers : ARRAY OF LONGREAL) : LONGREAL;
|
||||
VAR
|
||||
i,cnt : CARDINAL;
|
||||
mean : LONGREAL;
|
||||
BEGIN
|
||||
mean := 0.0;
|
||||
cnt := 0;
|
||||
FOR i:=0 TO HIGH(numbers) DO
|
||||
mean := mean + ( 1.0 / numbers[i]);
|
||||
INC(cnt);
|
||||
END;
|
||||
RETURN LFLOAT(cnt) / mean
|
||||
END HarmonicMean;
|
||||
|
||||
|
||||
CONST Size = 10;
|
||||
TYPE DA = ARRAY[1..Size] OF LONGREAL;
|
||||
|
||||
VAR
|
||||
buf : ARRAY[0..63] OF CHAR;
|
||||
array : DA;
|
||||
arithmetic,geometric,harmonic : LONGREAL;
|
||||
BEGIN
|
||||
array := DA{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);
|
||||
|
||||
WriteString("A = ");
|
||||
RealToStr(arithmetic, buf);
|
||||
WriteString(buf);
|
||||
WriteString(" G = ");
|
||||
RealToStr(geometric, buf);
|
||||
WriteString(buf);
|
||||
WriteString(" H = ");
|
||||
RealToStr(harmonic, buf);
|
||||
WriteString(buf);
|
||||
WriteLn;
|
||||
|
||||
FormatString("A >= G is %b, G >= H is %b\n", buf, arithmetic >= geometric, geometric >= harmonic);
|
||||
WriteString(buf);
|
||||
|
||||
ReadChar
|
||||
END PythagoreanMeans.
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/* 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
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
import math, sequtils, sugar
|
||||
|
||||
proc amean(num: seq[float]): float =
|
||||
sum(num) / float(len(num))
|
||||
|
||||
proc gmean(num: seq[float]): float =
|
||||
result = 1
|
||||
for n in num: result *= n
|
||||
result = pow(result, 1.0 / float(num.len))
|
||||
|
||||
proc hmean(num: seq[float]): 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(1.0 / it))
|
||||
|
||||
let numbers = toSeq(1..10).map((x: int) => float(x))
|
||||
echo amean(numbers), " ", gmean(numbers), " ", hmean(numbers)
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
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)
|
||||
;;
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
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)
|
||||
;;
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
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.
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
A = mean(list); % arithmetic mean
|
||||
G = mean(list,'g'); % geometric mean
|
||||
H = mean(list,'a'); % harmonic mean
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
import: mapping
|
||||
|
||||
: A ( x )
|
||||
x sum
|
||||
x size dup ifZero: [ 2drop null ] else: [ >float / ]
|
||||
;
|
||||
|
||||
: G( x ) #* x reduce x size inv powf ;
|
||||
|
||||
: H( x ) x size x map( #inv ) sum / ;
|
||||
|
||||
: averages
|
||||
| g |
|
||||
"Geometric mean :" . 10 seq G dup .cr ->g
|
||||
"Arithmetic mean :" . 10 seq A dup . g >= ifTrue: [ " ==> A >= G" .cr ]
|
||||
"Harmonic mean :" . 10 seq H dup . g <= ifTrue: [ " ==> G >= H" .cr ]
|
||||
;
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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)]
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
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]
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
<?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";
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
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');
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
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;
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
(phixonline)-->
|
||||
<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: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)/</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">geometric_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: #008080;">return</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">product</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">harmonic_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: #008080;">return</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)/</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">}</span>
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">arithmetic</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">arithmetic_mean</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">geometric</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">geometric_mean</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">harmonic</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">harmonic_mean</span><span style="color: #0000FF;">(</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;">"Arithmetic: %.10g\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">arithmetic</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;">"Geometric: %.10g\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">geometric</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>=Geometric>=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>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
(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 ) ) )
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
/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
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue