aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Task/Statistics-Basic/00-META.yaml Normal file
View file

@ -0,0 +1,3 @@
---
from: http://rosettacode.org/wiki/Statistics/Basic
note: Mathematics

34
Task/Statistics-Basic/00-TASK.txt Normal file
View file

@ -0,0 +1,34 @@
[[Statistics|Statistics]] is all about large groups of numbers.
When talking about a set of sampled data, most frequently used is their [[wp:Mean|mean value]] and [[wp:Standard_deviation|standard deviation (stddev)]].
If you have set of data <math>x_i</math> where <math>i = 1, 2, \ldots, n\,\!</math>, the mean is <math>\bar{x}\equiv {1\over n}\sum_i x_i</math>, while the stddev is <math>\sigma\equiv\sqrt{{1\over n}\sum_i \left(x_i - \bar x \right)^2}</math>.
When examining a large quantity of data, one often uses a [[wp:Histogram|histogram]], which shows the counts of data samples falling into a prechosen set of intervals (or bins).
When plotted, often as bar graphs, it visually indicates how often each data value occurs.
'''Task''' Using your language's random number routine, generate real numbers in the range of [0, 1]. It doesn't matter if you chose to use open or closed range.
Create 100 of such numbers (i.e. sample size 100) and calculate their mean and stddev.
Do so for sample size of 1,000 and 10,000, maybe even higher if you feel like.
Show a histogram of any of these sets.
Do you notice some patterns about the standard deviation?
'''Extra''' Sometimes so much data need to be processed that it's impossible to keep all of them at once. Can you calculate the mean, stddev and histogram of a trillion numbers? (You don't really need to do a trillion numbers, just show how it can be done.)
;Hint:
For a finite population with equal probabilities at all points, one can derive:
:<math>\overline{(x - \overline{x})^2} = \overline{x^2} - \overline{x}^2</math>
Or, more verbosely:
:<math>
\frac{1}{N}\sum_{i=1}^N(x_i-\overline{x})^2 = \frac{1}{N} \left(\sum_{i=1}^N x_i^2\right) - \overline{x}^2.
</math>
{{task heading|See also}}
* [[Statistics/Normal_distribution|Statistics/Normal distribution]]
{{Related tasks/Statistical measures}}
<br><hr>

22
Task/Statistics-Basic/11l/statistics-basic.11l Normal file
View file

@ -0,0 +1,22 @@
F sd_mean(numbers)
V mean = sum(numbers) / numbers.len
V sd = (sum(numbers.map(n -> (n - @mean) ^ 2)) / numbers.len) ^ 0.5
R (sd, mean)
F histogram(numbers)
V h = [0] * 10
V maxwidth = 50
L(n) numbers
h[Int(n * 10)]++
V mx = max(h)
print()
L(i) h
print(‘#.1: #.’.format(L.index / 10, ‘+’ * (i * maxwidth I/ mx)))
print()
L(i) (1, 5)
V n = (0 .< 10 ^ i).map(j -> random:())
print("\n####\n#### #. numbers\n####".format(10 ^ i))
V (sd, mean) = sd_mean(n)
print(‘ sd: #.6, mean: #.6’.format(sd, mean))
histogram(n)

87
Task/Statistics-Basic/ALGOL-68/statistics-basic.alg Normal file
View file

@ -0,0 +1,87 @@
BEGIN # calculate the mean and standard deviation of some data and draw a #
# histogram of the data #
# return the mean of data #
OP MEAN = ( []REAL data )REAL:
IF INT len = ( UPB data - LWB data ) + 1;
len < 1
THEN 0
ELSE REAL sum := 0;
FOR i FROM LWB data TO UPB data DO
sum +:= data[ i ]
OD;
sum / len
FI # MEAN # ;
# returns the standard deviation of data #
OP STDDEV = ( []REAL data )REAL:
IF INT len = ( UPB data - LWB data ) + 1;
len < 1
THEN 0
ELSE REAL m = MEAN data;
REAL sum := 0;
FOR i FROM LWB data TO UPB data DO
sum +:= ( data[ i ] - m ) ^ 2
OD;
sqrt( sum / len )
FI # STDDEV # ;
# generates a row of n random numbers in the range [0..1) #
PROC random row = ( INT n )REF[]REAL:
BEGIN
REF[]REAL data = HEAP[ 1 : n ]REAL;
FOR i TO n DO
data[ i ] := next random
OD;
data
END # random row # ;
# returns s right-padded with spaces to at least w characters #
PROC right pad = ( STRING s, INT w )STRING:
IF INT len = ( UPB s - LWB s ) + 1; len >= w THEN s ELSE s + ( " " * ( w - len ) ) FI;
# prints a histogram of data ( assumed to be in [0..1) ) with n bars #
# scaled to fit in h scale characters #
PROC print histogram = ( []REAL data, INT n, h scale )VOID:
IF n > 0 AND h scale > 0 THEN
[ 0 : n - 1 ]INT count;
FOR i FROM LWB count TO UPB count DO count[ i ] := 0 OD;
FOR i FROM LWB data TO UPB data DO
count[ ENTIER ( data[ i ] * n ) ] +:= 1
OD;
INT max count := 0;
FOR i FROM LWB count TO UPB count DO
IF count[ i ] > max count THEN max count := count[ i ] FI
OD;
INT len = ( UPB data - LWB data ) + 1;
REAL v := 0;
REAL scale = max count / h scale;
FOR i FROM LWB count TO UPB count DO
print( ( fixed( v, -4, 2 ), ": " ) );
print( ( right pad( "=" * ROUND ( count[ i ] / scale ), h scale ) ) );
print( ( " (", whole( count[ i ], 0 ), ")", newline ) );
v +:= 1 / n
OD
FI # print histogram # ;
# task #
# generate n random data items, calculate the mean and stddev and show #
# a histogram of the data #
PROC show statistics = ( INT n )VOID:
BEGIN
[]REAL data = random row( n );
print( ( "Sample size: ", whole( n, -6 ) ) );
print( ( ", mean: ", fixed( MEAN data, -8, 4 ) ) );
print( ( ", stddev: ", fixed( STDDEV data, -8, 4 ) ) );
print( ( newline ) );
print histogram( data, 10, 32 );
print( ( newline ) )
END # show statistics # ;
show statistics( 100 );
show statistics( 1 000 );
show statistics( 10 000 );
show statistics( 100 000 )
END

127
Task/Statistics-Basic/Action-/statistics-basic.action Normal file
View file

@ -0,0 +1,127 @@
INCLUDE "H6:REALMATH.ACT"
DEFINE SIZE="10000"
DEFINE HIST_SIZE="10"
BYTE ARRAY data(SIZE)
CARD ARRAY hist(HIST_SIZE)
PROC Generate()
INT i
FOR i=0 TO SIZE-1
DO
data(i)=Rand(0)
OD
RETURN
PROC CalcMean(INT count REAL POINTER mean)
REAL tmp1,tmp2,r255
INT i
IntToReal(0,mean)
IntToReal(255,r255)
FOR i=0 TO count-1
DO
IntToReal(data(i),tmp1)
RealDiv(tmp1,r255,tmp2)
RealAdd(mean,tmp2,tmp1)
RealAssign(tmp1,mean)
OD
IntToReal(count,tmp1)
RealDiv(mean,tmp1,tmp2)
RealAssign(tmp2,mean)
RETURN
PROC CalcStdDev(INT count REAL POINTER mean,sdev)
REAL tmp1,tmp2,r255
INT i
IntToReal(0,sdev)
IntToReal(255,r255)
FOR i=0 TO count-1
DO
IntToReal(data(i),tmp1)
RealDiv(tmp1,r255,tmp2)
RealSub(tmp2,mean,tmp1)
RealMult(tmp1,tmp1,tmp2)
RealAdd(sdev,tmp2,tmp1)
RealAssign(tmp1,sdev)
OD
IntToReal(count,tmp1)
RealDiv(sdev,tmp1,tmp2)
Sqrt(tmp2,sdev)
RETURN
PROC ClearHistogram()
BYTE i
FOR i=0 TO HIST_SIZE-1
DO
hist(i)=0
OD
RETURN
PROC CalcHistogram(INT count)
INT i,index
ClearHistogram()
FOR i=0 TO count-1
DO
index=data(i)*10/256
hist(index)==+1
OD
RETURN
PROC PrintHistogram()
BYTE i,j,n
INT max
REAL tmp1,tmp2,rmax,rlen
max=0
FOR i=0 TO HIST_SIZE-1
DO
IF hist(i)>max THEN
max=hist(i)
FI
OD
IntToReal(max,rmax)
IntToReal(25,rlen)
FOR i=0 TO HIST_SIZE-1
DO
PrintF("0.%Bx: ",i)
IntToReal(hist(i),tmp1)
RealMult(tmp1,rlen,tmp2)
RealDiv(tmp2,rmax,tmp1)
n=RealToInt(tmp1)
FOR j=0 TO n
DO
Put('*)
OD
PrintF(" %U",hist(i))
IF i<HIST_SIZE-1 THEN
PutE()
FI
OD
RETURN
PROC Test(INT count)
REAL mean,sdev
PrintI(count)
CalcMean(count,mean)
Print(": m=") PrintR(mean)
CalcStdDev(count,mean,sdev)
Print(" sd=") PrintRE(sdev)
CalcHistogram(count)
PrintHistogram()
RETURN
PROC Main()
Put(125) PutE() ;clear screen
MathInit()
Generate()
Test(100)
PutE() PutE()
Test(10000)
RETURN

63
Task/Statistics-Basic/Ada/statistics-basic-1.ada Normal file
View file

@ -0,0 +1,63 @@
with Ada.Text_IO, Ada.Command_Line, Ada.Numerics.Float_Random,
Ada.Numerics.Generic_Elementary_Functions;
procedure Basic_Stat is
package FRG renames Ada.Numerics.Float_Random;
package TIO renames Ada.Text_IO;
type Counter is range 0 .. 2**31-1;
type Result_Array is array(Natural range <>) of Counter;
package FIO is new TIO.Float_IO(Float);
procedure Put_Histogram(R: Result_Array; Scale, Full: Counter) is
begin
for I in R'Range loop
FIO.Put(Float'Max(0.0, Float(I)/10.0 - 0.05),
Fore => 1, Aft => 2, Exp => 0); TIO.Put("..");
FIO.Put(Float'Min(1.0, Float(I)/10.0 + 0.05),
Fore => 1, Aft => 2, Exp => 0); TIO.Put(": ");
for J in 1 .. (R(I)* Scale)/Full loop
Ada.Text_IO.Put("X");
end loop;
Ada.Text_IO.New_Line;
end loop;
end Put_Histogram;
procedure Put_Mean_Et_Al(Sample_Size: Counter;
Val_Sum, Square_Sum: Float) is
Mean: constant Float := Val_Sum / Float(Sample_Size);
package Math is new Ada.Numerics.Generic_Elementary_Functions(Float);
begin
TIO.Put("Mean: ");
FIO.Put(Mean, Fore => 1, Aft => 5, Exp => 0);
TIO.Put(", Standard Deviation: ");
FIO.Put(Math.Sqrt(abs(Square_Sum / Float(Sample_Size)
- (Mean * Mean))), Fore => 1, Aft => 5, Exp => 0);
TIO.New_Line;
end Put_Mean_Et_Al;
N: Counter := Counter'Value(Ada.Command_Line.Argument(1));
Gen: FRG.Generator;
Results: Result_Array(0 .. 10) := (others => 0);
X: Float;
Val_Sum, Squ_Sum: Float := 0.0;
begin
FRG.Reset(Gen);
for I in 1 .. N loop
X := FRG.Random(Gen);
Val_Sum := Val_Sum + X;
Squ_Sum := Squ_Sum + X*X;
declare
Index: Integer := Integer(X*10.0);
begin
Results(Index) := Results(Index) + 1;
end;
end loop;
TIO.Put_Line("After sampling" & Counter'Image(N) & " random numnbers: ");
Put_Histogram(Results, Scale => 600, Full => N);
TIO.New_Line;
Put_Mean_Et_Al(Sample_Size => N, Val_Sum => Val_Sum, Square_Sum => Squ_Sum);
end Basic_Stat;

77
Task/Statistics-Basic/Ada/statistics-basic-2.ada Normal file
View file

@ -0,0 +1,77 @@
with Ada.Text_IO, Ada.Command_Line, Ada.Numerics.Float_Random,
Ada.Numerics.Generic_Elementary_Functions;
procedure Long_Basic_Stat is
package FRG renames Ada.Numerics.Float_Random;
package TIO renames Ada.Text_IO;
type Counter is range 0 .. 2**63-1;
type Result_Array is array(Natural range <>) of Counter;
type High_Precision is digits 15;
package FIO is new TIO.Float_IO(Float);
procedure Put_Histogram(R: Result_Array; Scale, Full: Counter) is
begin
for I in R'Range loop
FIO.Put(Float'Max(0.0, Float(I)/10.0 - 0.05),
Fore => 1, Aft => 2, Exp => 0); TIO.Put("..");
FIO.Put(Float'Min(1.0, Float(I)/10.0 + 0.05),
Fore => 1, Aft => 2, Exp => 0); TIO.Put(": ");
for J in 1 .. (R(I)* Scale)/Full loop
Ada.Text_IO.Put("X");
end loop;
Ada.Text_IO.New_Line;
end loop;
end Put_Histogram;
procedure Put_Mean_Et_Al(Sample_Size: Counter;
Val_Sum, Square_Sum: Float) is
Mean: constant Float := Val_Sum / Float(Sample_Size);
package Math is new Ada.Numerics.Generic_Elementary_Functions(Float);
begin
TIO.Put("Mean: ");
FIO.Put(Mean, Fore => 1, Aft => 5, Exp => 0);
TIO.Put(", Standard Deviation: ");
FIO.Put(Math.Sqrt(abs(Square_Sum / Float(Sample_Size)
- (Mean * Mean))), Fore => 1, Aft => 5, Exp => 0);
TIO.New_Line;
end Put_Mean_Et_Al;
N: Counter := Counter'Value(Ada.Command_Line.Argument(1));
Gen: FRG.Generator;
Results: Result_Array(0 .. 10) := (others => 0);
X: Float;
Val_Sum, Squ_Sum: High_Precision := 0.0;
begin
FRG.Reset(Gen);
for Outer in 1 .. 1000 loop
for I in 1 .. N/1000 loop
X := FRG.Random(Gen);
Val_Sum := Val_Sum + High_Precision(X);
Squ_Sum := Squ_Sum + High_Precision(X)*High_Precision(X);
declare
Index: Integer := Integer(X*10.0);
begin
Results(Index) := Results(Index) + 1;
end;
end loop;
if Outer mod 50 = 0 then
TIO.New_Line(1);
TIO.Put_Line(Integer'Image(Outer/10) &"% done; current results:");
Put_Mean_Et_Al(Sample_Size => (Counter(Outer)*N)/1000,
Val_Sum => Float(Val_Sum),
Square_Sum => Float(Squ_Sum));
else
Ada.Text_IO.Put(".");
end if;
end loop;
TIO.New_Line(4);
TIO.Put_Line("After sampling" & Counter'Image(N) & " random numnbers: ");
Put_Histogram(Results, Scale => 600, Full => N);
TIO.New_Line;
Put_Mean_Et_Al(Sample_Size => N,
Val_Sum => Float(Val_Sum), Square_Sum => Float(Squ_Sum));
end Long_Basic_Stat;

39
Task/Statistics-Basic/Applesoft-BASIC/statistics-basic.basic Normal file
View file

@ -0,0 +1,39 @@
100 HOME : rem 100 CLS for Chipmunk Basic, GW-BASIC and MSX BASIC
110 CLEAR : n = 100 : GOSUB 150 : rem no se requiere CLEAR
120 CLEAR : n = 1000 : GOSUB 150
130 CLEAR : n = 10000 : GOSUB 150
140 END
150 rem SUB sample(n)
160 DIM samp(n)
170 FOR i = 1 TO n
180 samp(i) = RND(1)
190 NEXT i
200 rem calculate mean, standard deviation
210 sum = 0
220 sumsq = 0
230 FOR i = 1 TO n
240 sum = sum+samp(i)
250 sumsq = sumsq+samp(i)^2
260 NEXT i
270 PRINT "Sample size ";n
280 mean = sum/n
290 PRINT
300 PRINT " Mean = ";mean
310 PRINT " Std Dev = ";(sumsq/n-mean^2)^0.5
320 PRINT
330 rem------- Show histogram
340 scal = 10
350 DIM bins(scal)
360 FOR i = 1 TO n
370 z = INT(scal*samp(i))
380 bins(z) = bins(z)+1
390 NEXT i
400 FOR b = 0 TO scal-1
410 PRINT " ";b;" : ";
420 FOR j = 1 TO INT(scal*bins(b))/n*70
430 PRINT "*";
440 NEXT j
450 PRINT
460 NEXT b
470 PRINT
480 RETURN

48
Task/Statistics-Basic/C++/statistics-basic.cpp Normal file
View file

@ -0,0 +1,48 @@
#include <iostream>
#include <random>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
void printStars ( int number ) {
if ( number > 0 ) {
for ( int i = 0 ; i < number + 1 ; i++ )
std::cout << '*' ;
}
std::cout << '\n' ;
}
int main( int argc , char *argv[] ) {
const int numberOfRandoms = std::atoi( argv[1] ) ;
std::random_device rd ;
std::mt19937 gen( rd( ) ) ;
std::uniform_real_distribution<> distri( 0.0 , 1.0 ) ;
std::vector<double> randoms ;
for ( int i = 0 ; i < numberOfRandoms + 1 ; i++ )
randoms.push_back ( distri( gen ) ) ;
std::sort ( randoms.begin( ) , randoms.end( ) ) ;
double start = 0.0 ;
for ( int i = 0 ; i < 9 ; i++ ) {
double to = start + 0.1 ;
int howmany = std::count_if ( randoms.begin( ) , randoms.end( ),
[&start , &to] ( double c ) { return c >= start
&& c < to ; } ) ;
if ( start == 0.0 ) //double 0.0 output as 0
std::cout << "0.0" << " - " << to << ": " ;
else
std::cout << start << " - " << to << ": " ;
if ( howmany > 50 ) //scales big interval numbers to printable length
howmany = howmany / ( howmany / 50 ) ;
printStars ( howmany ) ;
start += 0.1 ;
}
double mean = std::accumulate( randoms.begin( ) , randoms.end( ) , 0.0 ) / randoms.size( ) ;
double sum = 0.0 ;
for ( double num : randoms )
sum += std::pow( num - mean , 2 ) ;
double stddev = std::pow( sum / randoms.size( ) , 0.5 ) ;
std::cout << "The mean is " << mean << " !" << std::endl ;
std::cout << "Standard deviation is " << stddev << " !" << std::endl ;
return 0 ;
}

32
Task/Statistics-Basic/C-sharp/statistics-basic.cs Normal file
View file

@ -0,0 +1,32 @@
using System;
using MathNet.Numerics.Statistics;
class Program
{
static void Run(int sampleSize)
{
double[] X = new double[sampleSize];
var r = new Random();
for (int i = 0; i < sampleSize; i++)
X[i] = r.NextDouble();
const int numBuckets = 10;
var histogram = new Histogram(X, numBuckets);
Console.WriteLine("Sample size: {0:N0}", sampleSize);
for (int i = 0; i < numBuckets; i++)
{
string bar = new String('#', (int)(histogram[i].Count * 360 / sampleSize));
Console.WriteLine(" {0:0.00} : {1}", histogram[i].LowerBound, bar);
}
var statistics = new DescriptiveStatistics(X);
Console.WriteLine(" Mean: " + statistics.Mean);
Console.WriteLine("StdDev: " + statistics.StandardDeviation);
Console.WriteLine();
}
static void Main(string[] args)
{
Run(100);
Run(1000);
Run(10000);
}
}

102
Task/Statistics-Basic/C/statistics-basic.c Normal file
View file

@ -0,0 +1,102 @@
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdint.h>
#define n_bins 10
double rand01() { return rand() / (RAND_MAX + 1.0); }
double avg(int count, double *stddev, int *hist)
{
double x[count];
double m = 0, s = 0;
for (int i = 0; i < n_bins; i++) hist[i] = 0;
for (int i = 0; i < count; i++) {
m += (x[i] = rand01());
hist[(int)(x[i] * n_bins)] ++;
}
m /= count;
for (int i = 0; i < count; i++)
s += x[i] * x[i];
*stddev = sqrt(s / count - m * m);
return m;
}
void hist_plot(int *hist)
{
int max = 0, step = 1;
double inc = 1.0 / n_bins;
for (int i = 0; i < n_bins; i++)
if (hist[i] > max) max = hist[i];
/* scale if numbers are too big */
if (max >= 60) step = (max + 59) / 60;
for (int i = 0; i < n_bins; i++) {
printf("[%5.2g,%5.2g]%5d ", i * inc, (i + 1) * inc, hist[i]);
for (int j = 0; j < hist[i]; j += step)
printf("#");
printf("\n");
}
}
/* record for moving average and stddev. Values kept are sums and sum data^2
* to avoid excessive precision loss due to divisions, but some loss is inevitable
*/
typedef struct {
uint64_t size;
double sum, x2;
uint64_t hist[n_bins];
} moving_rec;
void moving_avg(moving_rec *rec, double *data, int count)
{
double sum = 0, x2 = 0;
/* not adding data directly to the sum in case both recorded sum and
* count of this batch are large; slightly less likely to lose precision*/
for (int i = 0; i < count; i++) {
sum += data[i];
x2 += data[i] * data[i];
rec->hist[(int)(data[i] * n_bins)]++;
}
rec->sum += sum;
rec->x2 += x2;
rec->size += count;
}
int main()
{
double m, stddev;
int hist[n_bins], samples = 10;
while (samples <= 10000) {
m = avg(samples, &stddev, hist);
printf("size %5d: %g %g\n", samples, m, stddev);
samples *= 10;
}
printf("\nHistograph:\n");
hist_plot(hist);
printf("\nMoving average:\n N Mean Sigma\n");
moving_rec rec = { 0, 0, 0, {0} };
double data[100];
for (int i = 0; i < 10000; i++) {
for (int j = 0; j < 100; j++) data[j] = rand01();
moving_avg(&rec, data, 100);
if ((i % 1000) == 999) {
printf("%4lluk %f %f\n",
rec.size/1000,
rec.sum / rec.size,
sqrt(rec.x2 * rec.size - rec.sum * rec.sum)/rec.size
);
}
}
}

39
Task/Statistics-Basic/Chipmunk-Basic/statistics-basic.basic Normal file
View file

@ -0,0 +1,39 @@
100 sub sample(n)
110 dim samp(n)
120 for i = 1 to n
130 samp(i) = rnd(1)
140 next i
150 rem calculate mean, standard deviation
160 sum = 0
170 sumsq = 0
180 for i = 1 to n
190 sum = sum+samp(i)
200 sumsq = sumsq+samp(i)^2
210 next i
220 print "Sample size ";n
230 mean = sum/n
240 print
250 print " Mean = ";mean
260 print " Std Dev = ";(sumsq/n-mean^2)^0.5
270 print
280 rem------- Show histogram
290 scal = 10
300 dim bins(scal)
310 for i = 1 to n
320 z = int(scal*samp(i))
330 bins(z) = bins(z)+1
340 next i
350 for b = 0 to scal-1
360 print " ";b;" : ";
370 for j = 1 to int(scal*bins(b))/n*70
380 print "*";
390 next j
400 print
410 next b
420 print
430 end sub
440 cls
450 sample(100)
460 sample(1000)
470 sample(10000)
480 end

36
Task/Statistics-Basic/CoffeeScript/statistics-basic.coffee Normal file
View file

@ -0,0 +1,36 @@
generate_statistics = (n) ->
hist = {}
update_hist = (r) ->
hist[Math.floor 10*r] ||= 0
hist[Math.floor 10*r] += 1
sum = 0
sum_squares = 0.0
for i in [1..n]
r = Math.random()
sum += r
sum_squares += r*r
update_hist r
mean = sum / n
stddev = Math.sqrt((sum_squares / n) - mean*mean)
[n, mean, stddev, hist]
display_statistics = (n, mean, stddev, hist) ->
console.log "-- Stats for sample size #{n}"
console.log "mean: #{mean}"
console.log "sdev: #{stddev}"
for x, cnt of hist
bars = repeat "=", Math.floor(cnt*300/n)
console.log "#{x/10}: #{bars} #{cnt}"
repeat = (c, n) ->
s = ''
s += c for i in [1..n]
s
for n in [100, 1000, 10000, 1000000]
[n, mean, stddev, hist] = generate_statistics n
display_statistics n, mean, stddev, hist

45
Task/Statistics-Basic/D/statistics-basic.d Normal file
View file

@ -0,0 +1,45 @@
import std.stdio, std.algorithm, std.array, std.typecons,
std.range, std.exception;
auto meanStdDev(R)(R numbers) /*nothrow*/ @safe /*@nogc*/ {
if (numbers.empty)
return tuple(0.0L, 0.0L);
real sx = 0.0, sxx = 0.0;
ulong n;
foreach (x; numbers) {
sx += x;
sxx += x ^^ 2;
n++;
}
return tuple(sx / n, (n * sxx - sx ^^ 2) ^^ 0.5L / n);
}
void showHistogram01(R)(R numbers) /*@safe*/ {
enum maxWidth = 50; // N. characters.
ulong[10] bins;
foreach (immutable x; numbers) {
immutable index = cast(size_t)(x * bins.length);
enforce(index >= 0 && index < bins.length);
bins[index]++;
}
immutable real maxFreq = bins.reduce!max;
foreach (immutable n, immutable i; bins)
writefln(" %3.1f: %s", n / real(bins.length),
replicate("*", cast(int)(i / maxFreq * maxWidth)));
writeln;
}
version (statistics_basic_main) {
void main() @safe {
import std.random;
foreach (immutable p; 1 .. 7) {
auto n = iota(10L ^^ p).map!(_ => uniform(0.0L, 1.0L));
writeln(10L ^^ p, " numbers:");
writefln(" Mean: %8.6f, SD: %8.6f", n.meanStdDev.tupleof);
n.showHistogram01;
}
}
}

99
Task/Statistics-Basic/Dart/statistics-basic.dart Normal file
View file

@ -0,0 +1,99 @@
/* Import math library to get:
* 1) Square root function : Math.sqrt(x)
* 2) Power function : Math.pow(base, exponent)
* 3) Random number generator : Math.Random()
*/
import 'dart:math' as Math show sqrt, pow, Random;
// Returns average/mean of a list of numbers
num mean(List<num> l) => l.reduce((num value,num element)=>value+element)/l.length;
// Returns standard deviation of a list of numbers
num stdev(List<num> l) => Math.sqrt((1/l.length)*l.map((num x)=>x*x).reduce((num value,num element) => value+element) - Math.pow(mean(l),2));
/* CODE TO PRINT THE HISTOGRAM STARTS HERE
*
* Histogram has ten fields, one for every tenth between 0 and 1
* To do this, we save the histogram as a global variable
* that will hold the number of occurences of each tenth in the sample
*/
List<num> histogram = new List.filled(10,0);
/*
* METHOD TO CREATE A RANDOM SAMPLE OF n NUMBERS (Returns a list)
*
* While creating each value, this method also increments the
* appropriate index of the histogram
*/
List<num> randomsample(num n){
List<num> l = new List<num>(n);
histogram = new List.filled(10,0);
num random = new Math.Random();
for (int i = 0; i < n; i++){
l[i] = random.nextDouble();
histogram[conv(l[i])] += 1;
}
return l;
}
/*
* METHOD TO RETURN A STRING OF n ASTERIXES (yay ASCII art)
*/
String stars(num n){
String s = '';
for (int i = 0; i < n; i++){
s = s + '*';
}
return s;
}
/*
* METHOD TO DRAW THE HISTOGRAM
* 1) Get to total for all the values in the histogram
* 2) For every field in the histogram:
* a) Compute the frequency for every field in the histogram
* b) Print the frequency as asterixes
*/
void drawhistogram(){
int total = histogram.reduce((num element,num value)=>element+value);
double freq;
for (int i = 0; i < 10; i++){
freq = histogram[i]/total;
print('${i/10} - ${(i+1)/10} : ' + stars(conv(30*freq)));
}
}
/* HELPER METHOD:
* converts values between 0-1 to integers between 0-9 inclusive
* useful to figure out which random value generated
* corresponds to which field in the histogram
*/
int conv(num i) => (10*i).floor();
/* MAIN FUNCTION
*
* Create 5 histograms and print the mean and standard deviation for each:
* 1) Sample Size = 100
* 2) Sample Size = 1000
* 3) Sample Size = 10000
* 4) Sample Size = 100000
* 5) Sample Size = 1000000
*
*/
void main(){
List<num> l;
num m;
num s;
List<int> sampleSizes = [100,1000,10000,100000,1000000];
for (int samplesize in sampleSizes){
print('--------------- Sample size $samplesize ----------------');
l = randomsample(samplesize);
m = mean(l);
s = stdev(l);
drawhistogram();
print('');
print('mean: ${m.toStringAsPrecision(8)} standard deviation: ${s.toStringAsPrecision(8)}');
print('');
}
}

27
Task/Statistics-Basic/Elixir/statistics-basic.elixir Normal file
View file

@ -0,0 +1,27 @@
defmodule Statistics do
def basic(n) do
{sum, sum2, hist} = generate(n)
mean = sum / n
stddev = :math.sqrt(sum2 / n - mean*mean)
IO.puts "size: #{n}"
IO.puts "mean: #{mean}"
IO.puts "stddev: #{stddev}"
Enum.each(0..9, fn i ->
:io.fwrite "~.1f:~s~n", [0.1*i, String.duplicate("=", trunc(500 * hist[i] / n))]
end)
IO.puts ""
end
defp generate(n) do
hist = for i <- 0..9, into: %{}, do: {i,0}
Enum.reduce(1..n, {0, 0, hist}, fn _,{sum, sum2, h} ->
r = :rand.uniform
{sum+r, sum2+r*r, Map.update!(h, trunc(10*r), &(&1+1))}
end)
end
end
Enum.each([100,1000,10000], fn n ->
Statistics.basic(n)
end)

37
Task/Statistics-Basic/Factor/statistics-basic.factor Normal file
View file

@ -0,0 +1,37 @@
USING: assocs formatting grouping io kernel literals math
math.functions math.order math.statistics prettyprint random
sequences sequences.deep sequences.repeating ;
IN: rosetta-code.statistics-basic
CONSTANT: granularity
$[ 11 iota [ 10 /f ] map 2 clump ]
: mean/std ( seq -- a b )
[ mean ] [ population-std ] bi ;
: .mean/std ( seq -- )
mean/std [ "Mean: " write . ] [ "STD: " write . ] bi* ;
: count-between ( seq a b -- n )
[ between? ] 2curry count ;
: histo ( seq -- seq )
granularity [ first2 count-between ] with map ;
: bar ( n -- str )
[ dup 50 < ] [ 10 / ] until 2 * >integer "*" swap repeat ;
: (.histo) ( seq -- seq' )
[ bar ] map granularity swap zip flatten 3 group ;
: .histo ( seq -- )
(.histo) [ "%.1f - %.1f %s\n" vprintf ] each ;
: stats ( n -- )
dup "Statistics %d:\n" printf
random-units [ histo .histo ] [ .mean/std nl ] bi ;
: main ( -- )
{ 100 1,000 10,000 } [ stats ] each ;
MAIN: main

36
Task/Statistics-Basic/Fortran/statistics-basic.f Normal file
View file

@ -0,0 +1,36 @@
program basic_stats
implicit none
integer, parameter :: i64 = selected_int_kind(18)
integer, parameter :: r64 = selected_real_kind(15)
integer(i64), parameter :: samples = 1000000000_i64
real(r64) :: r
real(r64) :: mean, stddev
real(r64) :: sumn = 0, sumnsq = 0
integer(i64) :: n = 0
integer(i64) :: bin(10) = 0
integer :: i, ind
call random_seed
n = 0
do while(n <= samples)
call random_number(r)
ind = r * 10 + 1
bin(ind) = bin(ind) + 1_i64
sumn = sumn + r
sumnsq = sumnsq + r*r
n = n + 1_i64
end do
mean = sumn / n
stddev = sqrt(sumnsq/n - mean*mean)
write(*, "(a, i0)") "sample size = ", samples
write(*, "(a, f17.15)") "Mean : ", mean,
write(*, "(a, f17.15)") "Stddev : ", stddev
do i = 1, 10
write(*, "(f3.1, a, a)") real(i)/10.0, ": ", repeat("=", int(bin(i)*500/samples))
end do
end program

69
Task/Statistics-Basic/FreeBASIC/statistics-basic.basic Normal file
View file

@ -0,0 +1,69 @@
' FB 1.05.0 Win64
Randomize
Sub basicStats(sampleSize As Integer)
If sampleSize < 1 Then Return
Dim r(1 To sampleSize) As Double
Dim h(0 To 9) As Integer '' all zero by default
Dim sum As Double = 0.0
Dim hSum As Integer = 0
' Generate 'sampleSize' random numbers in the interval [0, 1)
' calculate their sum
' and in which box they will fall when drawing the histogram
For i As Integer = 1 To sampleSize
r(i) = Rnd
sum += r(i)
h(Int(r(i) * 10)) += 1
Next
For i As Integer = 0 To 9 : hSum += h(i) : Next
' adjust one of the h() values if necessary to ensure hSum = sampleSize
Dim adj As Integer = sampleSize - hSum
If adj <> 0 Then
For i As Integer = 0 To 9
h(i) += adj
If h(i) >= 0 Then Exit For
h(i) -= adj
Next
End If
Dim mean As Double = sum / sampleSize
Dim sd As Double
sum = 0.0
' Now calculate their standard deviation
For i As Integer = 1 To sampleSize
sum += (r(i) - mean) ^ 2.0
Next
sd = Sqr(sum/sampleSize)
' Draw a histogram of the data with interval 0.1
Dim numStars As Integer
' If sample size > 500 then normalize histogram to 500
Dim scale As Double = 1.0
If sampleSize > 500 Then scale = 500.0 / sampleSize
Print "Sample size "; sampleSize
Print
Print Using " Mean #.######"; mean;
Print Using " SD #.######"; sd
Print
For i As Integer = 0 To 9
Print Using " #.## : "; i/10.0;
Print Using "##### " ; h(i);
numStars = Int(h(i) * scale + 0.5)
Print String(numStars, "*")
Next
End Sub
basicStats 100
Print
basicStats 1000
Print
basicStats 10000
Print
basicStats 100000
Print
Print "Press any key to quit"
Sleep

39
Task/Statistics-Basic/GW-BASIC/statistics-basic.basic Normal file
View file

@ -0,0 +1,39 @@
100 CLS : rem 100 HOME FOR Applesoft BASIC
110 CLEAR : n = 100 : GOSUB 150
120 CLEAR : n = 1000 : GOSUB 150
130 CLEAR : n = 10000 : GOSUB 150
140 END
150 rem SUB sample(n)
160 DIM samp(n)
170 FOR i = 1 TO n
180 samp(i) = RND(1)
190 NEXT i
200 rem calculate mean, standard deviation
210 sum = 0
220 sumsq = 0
230 FOR i = 1 TO n
240 sum = sum+samp(i)
250 sumsq = sumsq+samp(i)^2
260 NEXT i
270 PRINT "Sample size ";n
280 mean = sum/n
290 PRINT
300 PRINT " Mean = ";mean
310 PRINT " Std Dev = ";(sumsq/n-mean^2)^0.5
320 PRINT
330 rem------- Show histogram
340 scal = 10
350 DIM bins(scal)
360 FOR i = 1 TO n
370 z = INT(scal*samp(i))
380 bins(z) = bins(z)+1
390 NEXT i
400 FOR b = 0 TO scal-1
410 PRINT " ";b;" : ";
420 FOR j = 1 TO INT(scal*bins(b))/n*70
430 PRINT "*";
440 NEXT j
450 PRINT
460 NEXT b
470 PRINT
480 RETURN

41
Task/Statistics-Basic/Go/statistics-basic-1.go Normal file
View file

@ -0,0 +1,41 @@
package main
import (
"fmt"
"math"
"math/rand"
"strings"
)
func main() {
sample(100)
sample(1000)
sample(10000)
}
func sample(n int) {
// generate data
d := make([]float64, n)
for i := range d {
d[i] = rand.Float64()
}
// show mean, standard deviation
var sum, ssq float64
for _, s := range d {
sum += s
ssq += s * s
}
fmt.Println(n, "numbers")
m := sum / float64(n)
fmt.Println("Mean: ", m)
fmt.Println("Stddev:", math.Sqrt(ssq/float64(n)-m*m))
// show histogram
h := make([]int, 10)
for _, s := range d {
h[int(s*10)]++
}
for _, c := range h {
fmt.Println(strings.Repeat("*", c*205/int(n)))
}
fmt.Println()
}

64
Task/Statistics-Basic/Go/statistics-basic-2.go Normal file
View file

@ -0,0 +1,64 @@
package main
import (
"fmt"
"math"
"math/rand"
"strings"
)
func main() {
bigSample(1e7)
}
func bigSample(n int64) {
sum, ssq, h := reduce(0, n)
// compute final statistics and output as above
fmt.Println(n, "numbers")
m := sum / float64(n)
fmt.Println("Mean: ", m)
fmt.Println("Stddev:", math.Sqrt(ssq/float64(n)-m*m))
for _, c := range h {
fmt.Println(strings.Repeat("*", c*205/int(n)))
}
fmt.Println()
}
const threshold = 1e6
func reduce(start, end int64) (sum, ssq float64, h []int) {
n := end - start
if n < threshold {
d := getSegment(start, end)
return computeSegment(d)
}
// map to two sub problems
half := (start + end) / 2
sum1, ssq1, h1 := reduce(start, half)
sum2, ssq2, h2 := reduce(half, end)
// combine results
for i, c := range h2 {
h1[i] += c
}
return sum1 + sum2, ssq1 + ssq2, h1
}
func getSegment(start, end int64) []float64 {
d := make([]float64, end-start)
for i := range d {
d[i] = rand.Float64()
}
return d
}
func computeSegment(d []float64) (sum, ssq float64, h []int) {
for _, s := range d {
sum += s
ssq += s * s
}
h = make([]int, 10)
for _, s := range d {
h[int(s*10)]++
}
return
}

69
Task/Statistics-Basic/Haskell/statistics-basic.hs Normal file
View file

@ -0,0 +1,69 @@
import Data.Foldable (foldl') --'
import System.Random (randomRs, newStdGen)
import Control.Monad (zipWithM_)
import System.Environment (getArgs)
intervals :: [(Double, Double)]
intervals = map conv [0 .. 9]
where
xs = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
conv s =
let [h, l] = take 2 $ drop s xs
in (h, l)
count :: [Double] -> [Int]
count rands = map (\iv -> foldl'' (loop iv) 0 rands) intervals
where
loop :: (Double, Double) -> Int -> Double -> Int
loop (lo, hi) n x
| lo <= x && x < hi = n + 1
| otherwise = n
-- ^ fuses length and filter within (lo,hi)
data Pair a b =
Pair !a
!b
-- accumulate sum and length in one fold
sumLen :: [Double] -> Pair Double Double
sumLen = fion2 . foldl'' (\(Pair s l) x -> Pair (s + x) (l + 1)) (Pair 0.0 0)
where
fion2 :: Pair Double Int -> Pair Double Double
fion2 (Pair s l) = Pair s (fromIntegral l)
-- safe division on pairs
divl :: Pair Double Double -> Double
divl (Pair _ 0.0) = 0.0
divl (Pair s l) = s / l
-- sumLen and divl are separate for stddev below
mean :: [Double] -> Double
mean = divl . sumLen
stddev :: [Double] -> Double
stddev xs = sqrt $ foldl'' (\s x -> s + (x - m) ^ 2) 0 xs / l
where
p@(Pair s l) = sumLen xs
m = divl p
main = do
nr <- read . head <$> getArgs
-- or in code, e.g. let nr = 1000
rands <- take nr . randomRs (0.0, 1.0) <$> newStdGen
putStrLn $ "The mean is " ++ show (mean rands) ++ " !"
putStrLn $ "The standard deviation is " ++ show (stddev rands) ++ " !"
zipWithM_
(\iv fq -> putStrLn $ ivstr iv ++ ": " ++ fqstr fq)
intervals
(count rands)
where
fqstr i =
replicate
(if i > 50
then div i (div i 50)
else i)
'*'
ivstr (lo, hi) = show lo ++ " - " ++ show hi
-- To avoid Wiki formatting issue
foldl'' = foldl'

11
Task/Statistics-Basic/Hy/statistics-basic.hy Normal file
View file

@ -0,0 +1,11 @@
(import
[numpy.random [random]]
[numpy [mean std]]
[matplotlib.pyplot :as plt])
(for [n [100 1000 10000]]
(setv v (random n))
(print "Mean:" (mean v) "SD:" (std v)))
(plt.hist (random 1000))
(plt.show)

26
Task/Statistics-Basic/Icon/statistics-basic.icon Normal file
View file

@ -0,0 +1,26 @@
procedure main(A)
W := 50 # avg width for histogram bar
B := 10 # histogram bins
if *A = 0 then put(A,100) # 100 if none specified
while N := get(A) do { # once per argument
write("\nN=",N)
N := 0 < integer(N) | next # skip if invalid
stddev() # reset
m := 0.
H := list(B,0) # Histogram of
every i := 1 to N do { # calc running ...
s := stddev(r := ?0) # ... std dev
m +:= r/N # ... mean
H[integer(*H*r)+1] +:= 1 # ... histogram
}
write("mean=",m)
write("stddev=",s)
every i := 1 to *H do # show histogram
write(right(real(i)/*H,5)," : ",repl("*",integer(*H*50./N*H[i])))
}
end

7
Task/Statistics-Basic/J/statistics-basic-1.j Normal file
View file

@ -0,0 +1,7 @@
require 'stats'
(mean,stddev) 1000 ?@$ 0
0.484669 0.287482
(mean,stddev) 10000 ?@$ 0
0.503642 0.290777
(mean,stddev) 100000 ?@$ 0
0.499677 0.288726

3
Task/Statistics-Basic/J/statistics-basic-2.j Normal file
View file

@ -0,0 +1,3 @@
histogram=: <: @ (#/.~) @ (i.@#@[ , I.)
require'plot'
plot ((% * 1 + i.)100) ([;histogram) 10000 ?@$ 0

24
Task/Statistics-Basic/J/statistics-basic-3.j Normal file
View file

@ -0,0 +1,24 @@
histogram=: <: @ (#/.~) @ (i.@#@[ , I.)
meanstddevP=: 3 :0
NB. compute mean and std dev of y random numbers
NB. picked from even distribution between 0 and 1
NB. and display a normalized ascii histogram for this sample
NB. note: uses population mean (0.5), not sample mean, for stddev
NB. given the equation specified for this task.
h=.s=.t=. 0
chunk=. 1e6
bins=. (%~ 1 + i.) 10
for. i. <.y%chunk do.
data=. chunk ?@$ 0
h=. h+ bins histogram data
s=. s+ +/ data
t=. t+ +/ *: data-0.5
end.
data=. (chunk|y) ?@$ 0
h=. h+ bins histogram data
s=. s+ +/ data
t=. t+ +/ *: data - 0.5
smoutput (<.300*h%y) #"0 '#'
(s%y) , %:t%y
)

36
Task/Statistics-Basic/J/statistics-basic-4.j Normal file
View file

@ -0,0 +1,36 @@
meanstddevP 1000
#############################
####################################
###########################
##############################
###################################
########################
###########################
############################
################################
##########################
0.488441 0.289744
meanstddevP 10000
##############################
##############################
#############################
#############################
###############################
##############################
############################
##############################
#############################
#############################
0.49697 0.289433
meanstddevP 100000
#############################
##############################
#############################
#############################
#############################
##############################
##############################
##############################
##############################
#############################
0.500872 0.288241

52
Task/Statistics-Basic/Java/statistics-basic.java Normal file
View file

@ -0,0 +1,52 @@
import static java.lang.Math.pow;
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.joining;
import static java.util.stream.IntStream.range;
public class Test {
static double[] meanStdDev(double[] numbers) {
if (numbers.length == 0)
return new double[]{0.0, 0.0};
double sx = 0.0, sxx = 0.0;
long n = 0;
for (double x : numbers) {
sx += x;
sxx += pow(x, 2);
n++;
}
return new double[]{sx / n, pow((n * sxx - pow(sx, 2)), 0.5) / n};
}
static String replicate(int n, String s) {
return range(0, n + 1).mapToObj(i -> s).collect(joining());
}
static void showHistogram01(double[] numbers) {
final int maxWidth = 50;
long[] bins = new long[10];
for (double x : numbers)
bins[(int) (x * bins.length)]++;
double maxFreq = stream(bins).max().getAsLong();
for (int i = 0; i < bins.length; i++)
System.out.printf(" %3.1f: %s%n", i / (double) bins.length,
replicate((int) (bins[i] / maxFreq * maxWidth), "*"));
System.out.println();
}
public static void main(String[] a) {
Locale.setDefault(Locale.US);
for (int p = 1; p < 7; p++) {
double[] n = range(0, (int) pow(10, p))
.mapToDouble(i -> Math.random()).toArray();
System.out.println((int)pow(10, p) + " numbers:");
double[] res = meanStdDev(n);
System.out.printf(" Mean: %8.6f, SD: %8.6f%n", res[0], res[1]);
showHistogram01(n);
}
}
}

4
Task/Statistics-Basic/Jq/statistics-basic-1.jq Normal file
View file

@ -0,0 +1,4 @@
# Usage: prng N width
function prng {
cat /dev/urandom | tr -cd '0-9' | fold -w "$2" | head -n "$1"
}

32
Task/Statistics-Basic/Jq/statistics-basic-2.jq Normal file
View file

@ -0,0 +1,32 @@
# $histogram should be a JSON object, with buckets as keys and frequencies as values;
# $keys should be an array of all the potential bucket names (possibly integers)
# in the order to be used for display:
def pp($histogram; $keys):
([$histogram[]] | add) as $n # for scaling
| ($keys|length) as $length
| $keys[]
| "\(.) : \("*" * (($histogram[tostring] // 0) * 20 * $length / $n) // "" )" ;
# `basic_stats` computes the unadjusted standard deviation
# and assumes the sum of squares (ss) can be computed without concern for overflow.
# The histogram is based on allocation to a bucket, which is made
# using `bucketize`, e.g. `.*10|floor`
def basic_stats(stream; bucketize):
# Use
reduce stream as $x ({histogram: {}};
.count += 1
| .sum += $x
| .ss += $x * $x
| ($x | bucketize | tostring) as $bucket
| .histogram[$bucket] += 1 )
| .mean = (.sum / .count)
| .stddev = (((.ss/.count) - .mean*.mean) | sqrt) ;
basic_stats( "0." + inputs | tonumber; .*10|floor)
| "
Basic statistics for \(.count) PRNs in [0,1]:
mean: \(.mean)
stddev: \(.stddev)
Histogram dividing [0,1] into 10 equal intervals:",
pp(.histogram; [range(0;10)] )

5
Task/Statistics-Basic/Jq/statistics-basic-3.jq Normal file
View file

@ -0,0 +1,5 @@
for n in 100 1000 1000000 100000000; do
echo "Basic statistics for $n PRNs in [0,1]"
prng $n 10 | jq -nrR -f basicStats.jq
echo
done

110
Task/Statistics-Basic/Jsish/statistics-basic.jsish Normal file
View file

@ -0,0 +1,110 @@
#!/usr/bin/env jsish
"use strict";
function statisticsBasic(args:array|string=void, conf:object=void) {
var options = { // Rosetta Code, Statistics/Basic
rootdir :'', // Root directory.
samples : 0 // Set sample size from options
};
var self = { };
parseOpts(self, options, conf);
function generateStats(n:number):object {
var i, sum = 0, sum2 = 0;
var hist = new Array(10);
hist.fill(0);
for (i = 0; i < n; i++) {
var r = Math.random();
sum += r;
sum2 += r*r;
hist[Math.floor((r*10))] += 1;
}
var mean = sum/n;
var stddev = Math.sqrt((sum2 / n) - mean*mean);
var obj = {n:n, sum:sum, mean:mean, stddev:stddev};
return {n:n, sum:sum, mean:mean, stddev:stddev, hist:hist};
}
function reportStats(summary:object):void {
printf("Samples: %d, mean: %f, stddev: %f\n", summary.n, summary.mean, summary.stddev);
var max = Math.max.apply(summary, summary.hist);
for (var i = 0; i < 10; i++) {
printf("%3.1f+ %-70s %5d\n", i * 0.1, 'X'.repeat(70 * summary.hist[i] / max), summary.hist[i]);
}
return;
}
function main() {
LogTest('Starting', args);
switch (typeof(args)) {
case 'string': args = [args]; break;
case 'array': break;
default: args = [];
}
if (self.rootdir === '')
self.rootdir=Info.scriptDir();
Math.srand(0);
if (self.samples > 0) reportStats(generateStats(self.samples));
else if (args[0] && parseInt(args[0])) reportStats(generateStats(parseInt(args[0])));
else for (var n of [100, 1000, 10000]) reportStats(generateStats(n));
debugger;
LogDebug('Done');
return 0;
}
return main();
}
provide(statisticsBasic, 1);
if (isMain()) {
if (!Interp.conf('unitTest'))
return runModule(statisticsBasic);
;' statisticsBasic unit-test';
; statisticsBasic();
}
/*
=!EXPECTSTART!=
' statisticsBasic unit-test'
statisticsBasic() ==> Samples: 100, mean: 0.534517, stddev: 0.287124
0.0+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 8
0.1+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 11
0.2+ XXXXXXXXXXXXXXXXXXXXXXXXXX 6
0.3+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 10
0.4+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 10
0.5+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 11
0.6+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 8
0.7+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 16
0.8+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 7
0.9+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 13
Samples: 1000, mean: 0.490335, stddev: 0.286562
0.0+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 98
0.1+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 122
0.2+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 85
0.3+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 106
0.4+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 105
0.5+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 101
0.6+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 93
0.7+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 106
0.8+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 98
0.9+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 86
Samples: 10000, mean: 0.499492, stddev: 0.287689
0.0+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 969
0.1+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 992
0.2+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1067
0.3+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1011
0.4+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 973
0.5+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1031
0.6+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 971
0.7+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 999
0.8+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 991
0.9+ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 996
0
=!EXPECTEND!=
*/

20
Task/Statistics-Basic/Julia/statistics-basic.julia Normal file
View file

@ -0,0 +1,20 @@
using Printf
function hist(numbers)
maxwidth = 50
h = fill(0, 10)
for n in numbers
h[ceil(Int, 10n)] += 1
end
mx = maximum(h)
for (n, i) in enumerate(h)
@printf("%3.1f: %s\n", n / 10, "+" ^ floor(Int, i / mx * maxwidth))
end
end
for i in 1:6
n = rand(10 ^ i)
println("\n##\n## $(10 ^ i) numbers")
@printf("μ: %8.6f; σ: %8.6f\n", mean(n), std(n))
hist(n)
end

9
Task/Statistics-Basic/Klong/statistics-basic.klong Normal file
View file

@ -0,0 +1,9 @@
.l("nstat.kg")
bar::{x{x;.d("*")}:*0;.p("")}
hist10::{[s];#'=s@<s::_x*10}
plot::{[s];.p("");.p("n = ",$x);
(!10){.d(x%10);.d(" ");bar(y)}'_(100%x)*(hist10(s::{x;.rn()}'!x));
.p("mean = ",$mu(s));.p("sd = ",$sd(s))}
plot(100)
plot(1000)
plot(10000)

49
Task/Statistics-Basic/Kotlin/statistics-basic.kotlin Normal file
View file

@ -0,0 +1,49 @@
// version 1.1.2
val rand = java.util.Random()
fun basicStats(sampleSize: Int) {
if (sampleSize < 1) return
val r = DoubleArray(sampleSize)
val h = IntArray(10) // all zero by default
/*
Generate 'sampleSize' random numbers in the interval [0, 1)
and calculate in which box they will fall when drawing the histogram
*/
for (i in 0 until sampleSize) {
r[i] = rand.nextDouble()
h[(r[i] * 10).toInt()]++
}
// adjust one of the h[] values if necessary to ensure they sum to sampleSize
val adj = sampleSize - h.sum()
if (adj != 0) {
for (i in 0..9) {
h[i] += adj
if (h[i] >= 0) break
h[i] -= adj
}
}
val mean = r.average()
val sd = Math.sqrt(r.map { (it - mean) * (it - mean) }.average())
// Draw a histogram of the data with interval 0.1
var numStars: Int
// If sample size > 500 then normalize histogram to 500
val scale = if (sampleSize <= 500) 1.0 else 500.0 / sampleSize
println("Sample size $sampleSize\n")
println(" Mean ${"%1.6f".format(mean)} SD ${"%1.6f".format(sd)}\n")
for (i in 0..9) {
print(" %1.2f : ".format(i / 10.0))
print("%5d ".format(h[i]))
numStars = (h[i] * scale + 0.5).toInt()
println("*".repeat(numStars))
}
println()
}
fun main(args: Array<String>) {
val sampleSizes = intArrayOf(100, 1_000, 10_000, 100_000)
for (sampleSize in sampleSizes) basicStats(sampleSize)
}

51
Task/Statistics-Basic/Lasso/statistics-basic.lasso Normal file
View file

@ -0,0 +1,51 @@
define stat1(a) => {
if(#a->size) => {
local(mean = (with n in #a sum #n) / #a->size)
local(sdev = math_pow(((with n in #a sum Math_Pow((#n - #mean),2)) / #a->size),0.5))
return (:#sdev, #mean)
else
return (:0,0)
}
}
define stat2(a) => {
if(#a->size) => {
local(sx = 0, sxx = 0)
with x in #a do => {
#sx += #x
#sxx += #x*#x
}
local(sdev = math_pow((#a->size * #sxx - #sx * #sx),0.5) / #a->size)
return (:#sdev, #sx / #a->size)
else
return (:0,0)
}
}
define histogram(a) => {
local(
out = '\r',
h = array(0,0,0,0,0,0,0,0,0,0,0),
maxwidth = 50,
sc = 0
)
with n in #a do => {
#h->get(integer(#n*10)+1) += 1
}
local(mx = decimal(with n in #h max #n))
with i in #h do => {
#out->append((#sc/10.0)->asString(-precision=1)+': '+('+' * integer(#i / #mx * #maxwidth))+'\r')
#sc++
}
return #out
}
with scale in array(100,1000,10000,100000) do => {^
local(n = array)
loop(#scale) => { #n->insert(decimal_random) }
local(sdev1,mean1) = stat1(#n)
local(sdev2,mean2) = stat2(#n)
#scale' numbers:\r'
'Naive method: sd: '+#sdev1+', mean: '+#mean1+'\r'
'Second method: sd: '+#sdev2+', mean: '+#mean2+'\r'
histogram(#n)
'\r\r'
^}

41
Task/Statistics-Basic/Liberty-BASIC/statistics-basic.basic Normal file
View file

@ -0,0 +1,41 @@
call sample 100
call sample 1000
call sample 10000
end
sub sample n
dim dat( n)
for i =1 to n
dat( i) =rnd( 1)
next i
'// show mean, standard deviation
sum =0
sSq =0
for i =1 to n
sum =sum +dat( i)
sSq =sSq +dat( i)^2
next i
print n; " data terms used."
mean =sum / n
print "Mean ="; mean
print "Stddev ="; ( sSq /n -mean^2)^0.5
'// show histogram
nBins =10
dim bins( nBins)
for i =1 to n
z =int( nBins *dat( i))
bins( z) =bins( z) +1
next i
for b =0 to nBins -1
for j =1 to int( nBins *bins( b)) /n *70)
print "#";
next j
print
next b
print
end sub

56
Task/Statistics-Basic/Lua/statistics-basic.lua Normal file
View file

@ -0,0 +1,56 @@
math.randomseed(os.time())
function randList (n) -- Build table of size n
local numbers = {}
for i = 1, n do
table.insert(numbers, math.random()) -- range correct by default
end
return numbers
end
function mean (t) -- Find mean average of values in table t
local sum = 0
for k, v in pairs(t) do
sum = sum + v
end
return sum / #t
end
function stdDev (t) -- Find population standard deviation of table t
local squares, avg = 0, mean(t)
for k, v in pairs(t) do
squares = squares + ((avg - v) ^ 2)
end
local variance = squares / #t
return math.sqrt(variance)
end
function showHistogram (t) -- Draw histogram of given table to stdout
local histBars, compVal = {}
for range = 0, 9 do
histBars[range] = 0
for k, v in pairs(t) do
compVal = tonumber(string.format("%0.1f", v - 0.05))
if compVal == range / 10 then
histBars[range] = histBars[range] + 1
end
end
end
for k, v in pairs(histBars) do
io.write("0." .. k .. " " .. string.rep('=', v / #t * 200))
print(" " .. v)
end
print()
end
function showStats (tabSize) -- Create and display statistics info
local numList = randList(tabSize)
print("Table of size " .. #numList)
print("Mean average: " .. mean(numList))
print("Standard dev: " .. stdDev(numList))
showHistogram(numList)
end
for power = 2, 5 do -- Start of main procedure
showStats(10 ^ power)
end

20
Task/Statistics-Basic/MATLAB/statistics-basic.m Normal file
View file

@ -0,0 +1,20 @@
% Initialize
N = 0; S=0; S2 = 0;
binlist = 0:.1:1;
h = zeros(1,length(binlist)); % initialize histogram
% read data and perform computation
while (1)
% read next sample x
if (no_data_available) break; end;
N = N + 1;
S = S + x;
S2= S2+ x*x;
ix= sum(x < binlist);
h(ix) = h(ix)+1;
end
% generate output
m = S/N; % mean
sd = sqrt(S2/N-mean*mean); % standard deviation
bar(binlist,h)

5
Task/Statistics-Basic/Maple/statistics-basic-1.maple Normal file
View file

@ -0,0 +1,5 @@
with(Statistics):
X_100 := Sample( Uniform(0,1), 100 );
Mean( X_100 );
StandardDeviation( X_100 );
Histogram( X_100 );

9
Task/Statistics-Basic/Maple/statistics-basic-2.maple Normal file
View file

@ -0,0 +1,9 @@
sample := proc( n )
local data;
data := Sample( Uniform(0,1), n );
printf( "Mean: %.4f\nStandard Deviation: %.4f",
Statistics:-Mean( data ),
Statistics:-StandardDeviation( data ) );
return Statistics:-Histogram( data );
end proc:
sample( 1000 );

3
Task/Statistics-Basic/Mathematica/statistics-basic.math Normal file
View file

@ -0,0 +1,3 @@
Sample[n_]:= (Print[#//Length," numbers, Mean : ",#//Mean,", StandardDeviation : ",#//StandardDeviation ];
BarChart[BinCounts[#,{0,1,.1}], Axes->False, BarOrigin->Left])&[(RandomReal[1,#])&[ n ]]
Sample/@{100,1 000,10 000,1 000 000}

39
Task/Statistics-Basic/MiniScript/statistics-basic.mini Normal file
View file

@ -0,0 +1,39 @@
Stats = {}
Stats.count = 0
Stats.sum = 0
Stats.sumOfSquares = 0
Stats.histo = null
Stats.add = function(x)
self.count = self.count + 1
self.sum = self.sum + x
self.sumOfSquares = self.sumOfSquares + x*x
bin = floor(x*10)
if not self.histo then self.histo = [0]*10
self.histo[bin] = self.histo[bin] + 1
end function
Stats.mean = function()
return self.sum / self.count
end function
Stats.stddev = function()
m = self.sum / self.count
return sqrt(self.sumOfSquares / self.count - m*m)
end function
Stats.histogram = function()
for i in self.histo.indexes
print "0." + i + ": " + "=" * (self.histo[i]/self.count * 200)
end for
end function
for sampleSize in [100, 1000, 10000]
print "Samples: " + sampleSize
st = new Stats
for i in range(sampleSize)
st.add rnd
end for
print "Mean: " + st.mean + " Standard Deviation: " + st.stddev
st.histogram
end for

32
Task/Statistics-Basic/Nim/statistics-basic.nim Normal file
View file

@ -0,0 +1,32 @@
import random, sequtils, stats, strutils, strformat
proc drawHistogram(ns: seq[float]) =
var h = newSeq[int](11)
for n in ns:
let pos = (n * 10).toInt
inc h[pos]
const maxWidth = 50
let mx = max(h)
echo ""
for n, count in h:
echo n.toFloat / 10, ": ", repeat('+', int(count / mx * maxWidth))
echo ""
randomize()
# First part: compute directly from a sequence of values.
echo "For 100 numbers:"
let ns = newSeqWith(100, rand(1.0))
echo &"μ = {ns.mean:.12f} σ = {ns.standardDeviation:.12f}"
ns.drawHistogram()
# Second part: compute incrementally using "RunningStat".
for count in [1_000, 10_000, 100_000, 1_000_000]:
echo &"For {count} numbers:"
var rs: RunningStat
for _ in 1..count:
let n = rand(1.0)
rs.push(n)
echo &"μ = {rs.mean:.12f} σ = {rs.standardDeviation:.12f}"
echo()

15
Task/Statistics-Basic/Oforth/statistics-basic.fth Normal file
View file

@ -0,0 +1,15 @@
: main(n)
| l m std i nb |
// Create list and calculate avg and stddev
ListBuffer init(n, #[ Float rand ]) dup ->l avg ->m
0 l apply(#[ sq +]) n / m sq - sqrt ->std
System.Out "n = " << n << ", avg = " << m << ", std = " << std << cr
// Histo
0.0 0.9 0.1 step: i [
l count(#[ between(i, i 0.1 +) ]) 400 * n / asInteger ->nb
System.Out i <<wjp(3, JUSTIFY_RIGHT, 2) " - " <<
i 0.1 + <<wjp(3, JUSTIFY_RIGHT, 2) " - " <<
StringBuffer new "*" <<n(nb) << cr
] ;

21
Task/Statistics-Basic/PARI-GP/statistics-basic-1.parigp Normal file
View file

@ -0,0 +1,21 @@
mean(v)={
vecsum(v)/#v
};
stdev(v,mu="")={
if(mu=="",mu=mean(v));
sqrt(sum(i=1,#v,(v[i]-mu)^2))/#v
};
histogram(v,bins=16,low=0,high=1)={
my(u=vector(bins),width=(high-low)/bins);
for(i=1,#v,u[(v[i]-low)\width+1]++);
u
};
show(n)={
my(v=vector(n,i,random(1.)),mu=mean(v),s=stdev(v,mu),h=histogram(v),sz=ceil(n/50/16));
for(i=1,16,for(j=1,h[i]\sz,print1("#"));print());
print("Mean: "mu);
print("Stdev: "s);
};
show(100);
show(1000);
show(10000);

4
Task/Statistics-Basic/PARI-GP/statistics-basic-2.parigp Normal file
View file

@ -0,0 +1,4 @@
rreal()={
my(pr=32*ceil(default(realprecision)*log(10)/log(4294967296))); \\ Current precision
random(2^pr)*1.>>pr
};

39
Task/Statistics-Basic/PL-I/statistics-basic.pli Normal file
View file

@ -0,0 +1,39 @@
stat: procedure options (main); /* 21 May 2014 */
stats: procedure (values, mean, standard_deviation);
declare (values(*), mean, standard_deviation) float;
declare n fixed binary (31) initial ( (hbound(values,1)) );
mean = sum(values)/n;
standard_deviation = sqrt( sum(values - mean)**2 / n);
end stats;
declare values (*) float controlled;
declare (mean, stddev) float;
declare bin(0:9) fixed;
declare (i, n) fixed binary (31);
do n = 100, 1000, 10000, 100000;
allocate values(n);
values = random();
call stats (values, mean, stddev);
if n = 100 then
do;
bin = 0;
do i = 1 to 100;
bin(10*values(i)) += 1;
end;
put skip list ('Histogram for 100 values:');
do i = 0 to 9; /* display histogram */
put skip list (repeat('.', bin(i)) );
end;
end;
put skip list (n || ' values: mean=' || mean, 'stddev=' || stddev);
free values;
end;
end stat;

24
Task/Statistics-Basic/Perl/statistics-basic.pl Normal file
View file

@ -0,0 +1,24 @@
my @histogram = (0) x 10;
my $sum = 0;
my $sum_squares = 0;
my $n = $ARGV[0];
for (1..$n) {
my $current = rand();
$sum+= $current;
$sum_squares+= $current ** 2;
$histogram[$current * @histogram]+= 1;
}
my $mean = $sum / $n;
print "$n numbers\n",
"Mean: $mean\n",
"Stddev: ", sqrt(($sum_squares / $n) - ($mean ** 2)), "\n";
for my $i (0..$#histogram) {
printf "%.1f - %.1f : ", $i/@histogram, (1 + $i)/@histogram;
print "*" x (30 * $histogram[$i] * @histogram/$n); # 30 stars expected per row
print "\n";
}

36
Task/Statistics-Basic/Phix/statistics-basic.phix Normal file
View file

@ -0,0 +1,36 @@
(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">generate_statistics</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">hist</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">sum_r</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">sum_squares</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0.0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rnd</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">sum_r</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">r</span>
<span style="color: #000000;">sum_squares</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">*</span><span style="color: #000000;">r</span>
<span style="color: #000000;">hist</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">*</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">mean</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sum_r</span> <span style="color: #0000FF;">/</span> <span style="color: #000000;">n</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">stddev</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">((</span><span style="color: #000000;">sum_squares</span> <span style="color: #0000FF;">/</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">-</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">*</span><span style="color: #000000;">mean</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">stddev</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hist</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">display_statistics</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">stddev</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">hist</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">stddev</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hist</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">x</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;">"-- Stats for sample size %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</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;">"mean: %g\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">mean</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;">"sdev: %g\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">stddev</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hist</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">cnt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">hist</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">bars</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'='</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cnt</span><span style="color: #0000FF;">*</span><span style="color: #000000;">300</span><span style="color: #0000FF;">/</span><span style="color: #000000;">n</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;">"%.1f: %s %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">bars</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cnt</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">5</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">display_statistics</span><span style="color: #0000FF;">(</span><span style="color: #000000;">generate_statistics</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">+(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">5</span><span style="color: #0000FF;">))))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--

28
Task/Statistics-Basic/PicoLisp/statistics-basic.l Normal file
View file

@ -0,0 +1,28 @@
(seed (time))
(scl 8)
(de statistics (Cnt . Prg)
(prinl Cnt " numbers")
(let (Sum 0 Sqr 0 Hist (need 10 NIL 0))
(do Cnt
(let N (run Prg 1) # Get next number
(inc 'Sum N)
(inc 'Sqr (*/ N N 1.0))
(inc (nth Hist (inc (/ N 0.1)))) ) )
(let M (*/ Sum Cnt)
(prinl "Mean: " (round M))
(prinl "StdDev: "
(round
(sqrt
(- (*/ Sqr Cnt) (*/ M M 1.0))
1.0 ) ) ) )
(for (I . H) Hist
(prin (format I 1) " ")
(do (*/ H 400 Cnt) (prin '=))
(prinl) ) ) )
(for I (2 4 6)
(statistics (** 10 I)
(rand 0 (dec 1.0)) )
(prinl) )

56
Task/Statistics-Basic/PureBasic/statistics-basic.basic Normal file
View file

@ -0,0 +1,56 @@
Procedure.f randomf()
#RNG_max_resolution = 2147483647
ProcedureReturn Random(#RNG_max_resolution) / #RNG_max_resolution
EndProcedure
Procedure sample(n)
Protected i, nBins, binNumber, tickMarks, maxBinValue
Protected.f sum, sumSq, mean
Dim dat.f(n)
For i = 1 To n
dat(i) = randomf()
Next
;show mean, standard deviation
For i = 1 To n
sum + dat(i)
sumSq + dat(i) * dat(i)
Next i
PrintN(Str(n) + " data terms used.")
mean = sum / n
PrintN("Mean =" + StrF(mean))
PrintN("Stddev =" + StrF((sumSq / n) - Sqr(mean * mean)))
;show histogram
nBins = 10
Dim bins(nBins)
For i = 1 To n
binNumber = Int(nBins * dat(i))
bins(binNumber) + 1
Next
maxBinValue = 1
For i = 0 To nBins
If bins(i) > maxBinValue
maxBinValue = bins(i)
EndIf
Next
#normalizedMaxValue = 70
For binNumber = 0 To nBins
tickMarks = Int(bins(binNumber) * #normalizedMaxValue / maxBinValue)
PrintN(ReplaceString(Space(tickMarks), " ", "#"))
Next
PrintN("")
EndProcedure
If OpenConsole()
sample(100)
sample(1000)
sample(10000)
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf

39
Task/Statistics-Basic/Python/statistics-basic.py Normal file
View file

@ -0,0 +1,39 @@
def sd1(numbers):
if numbers:
mean = sum(numbers) / len(numbers)
sd = (sum((n - mean)**2 for n in numbers) / len(numbers))**0.5
return sd, mean
else:
return 0, 0
def sd2(numbers):
if numbers:
sx = sxx = n = 0
for x in numbers:
sx += x
sxx += x*x
n += 1
sd = (n * sxx - sx*sx)**0.5 / n
return sd, sx / n
else:
return 0, 0
def histogram(numbers):
h = [0] * 10
maxwidth = 50 # characters
for n in numbers:
h[int(n*10)] += 1
mx = max(h)
print()
for n, i in enumerate(h):
print('%3.1f: %s' % (n / 10, '+' * int(i / mx * maxwidth)))
print()
if __name__ == '__main__':
import random
for i in range(1, 6):
n = [random.random() for j in range(10**i)]
print("\n##\n## %i numbers\n##" % 10**i)
print(' Naive method: sd: %8.6f, mean: %8.6f' % sd1(n))
print(' Second method: sd: %8.6f, mean: %8.6f' % sd2(n))
histogram(n)

40
Task/Statistics-Basic/QBasic/statistics-basic.basic Normal file
View file

@ -0,0 +1,40 @@
SUB sample (n)
DIM samp(n)
FOR i = 1 TO n
samp(i) = RND(1)
NEXT i
REM calculate mean, standard deviation
sum = 0
sumsq = 0
FOR i = 1 TO n
sum = sum + samp(i)
sumsq = sumsq + samp(i) ^ 2
NEXT i
PRINT "Sample size "; n
mean = sum / n
PRINT
PRINT " Mean = "; mean
PRINT " Std Dev = "; (sumsq / n - mean ^ 2) ^ .5
PRINT
REM------- Show histogram
scal = 10
DIM bins(scal)
FOR i = 1 TO n
z = INT(scal * samp(i))
bins(z) = bins(z) + 1
NEXT i
FOR b = 0 TO scal - 1
PRINT " "; b; " : ";
FOR j = 1 TO INT(scal * bins(b)) / n * 70
PRINT "*";
NEXT j
PRINT
NEXT b
PRINT
END SUB
CLS
sample (100)
sample (1000)
sample (10000)
END

26
Task/Statistics-Basic/R/statistics-basic.r Normal file
View file

@ -0,0 +1,26 @@
#Generate the sets
a = runif(10,min=0,max=1)
b = runif(100,min=0,max=1)
c = runif(1000,min=0,max=1)
d = runif(10000,min=0,max=1)
#Print out the set of 10 values
cat("a = ",a)
#Print out the Mean and Standard Deviations of each of the sets
cat("Mean of a : ",mean(a))
cat("Standard Deviation of a : ", sd(a))
cat("Mean of b : ",mean(b))
cat("Standard Deviation of b : ", sd(b))
cat("Mean of c : ",mean(c))
cat("Standard Deviation of c : ", sd(c))
cat("Mean of d : ",mean(d))
cat("Standard Deviation of d : ", sd(d))
#Plotting the histogram of d
hist(d)
#Following lines error out due to insufficient memory
cat("Mean of a trillion random values in the range [0,1] : ",mean(runif(10^12,min=0,max=1)))
cat("Standard Deviation of a trillion random values in the range [0,1] : ", sd(runif(10^12,min=0,max=1)))

32
Task/Statistics-Basic/REXX/statistics-basic.rexx Normal file
View file

@ -0,0 +1,32 @@
/*REXX program generates some random numbers, shows bin histogram, finds mean & stdDev. */
numeric digits 20 /*use twenty decimal digits precision, */
showDigs=digits()%2 /* ··· but only show ten decimal digits*/
parse arg size seed . /*allow specification: size, and seed.*/
if size=='' | size=="," then size=100 /*Not specified? Then use the default.*/
if datatype(seed,'W') then call random ,,seed /*allow a seed for the RANDOM BIF. */
#.=0 /*count of the numbers in each bin. */
do j=1 for size /*generate some random numbers. */
@.j=random(, 99999) / 100000 /*express random number as a fraction. */
_=substr(@.j'00', 3, 1) /*determine which bin the number is in,*/
#._=#._ + 1 /* ··· and bump its count. */
end /*j*/
do k=0 for 10; kp=k + 1 /*show a histogram of the bins. */
lr='0.'k ; if k==0 then lr= "0 " /*adjust for the low range. */
hr='0.'kp ; if k==9 then hr= "1 " /* " " " high range. */
barPC=right( strip( left( format( 100*#.k / size, , 2), 5)), 5) /*compute the %. */
say lr"──►"hr' ' barPC copies("─", barPC * 2 % 1 ) /*show histogram.*/
end /*k*/
say
say 'sample size = ' size; say
avg= mean(size) ; say ' mean = ' format(avg, , showDigs)
std=stdDev(size) ; say ' stdDev = ' format(std, , showDigs)
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
mean: arg N; $=0; do m=1 for N; $=$ + @.m; end; return $/N
stdDev: arg N; $=0; do s=1 for N; $=$ + (@.s-avg)**2; end; return sqrt($/N) /1
/*──────────────────────────────────────────────────────────────────────────────────────*/
sqrt: procedure; parse arg x; if x=0 then return 0; d=digits(); m.=9; numeric form; h=d+6
numeric digits; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g=g*.5'e'_ % 2
do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/
do k=j+5 to 0 by -1; numeric digits m.k; g=(g+x/g)*.5; end /*k*/; return g

21
Task/Statistics-Basic/Racket/statistics-basic.rkt Normal file
View file

@ -0,0 +1,21 @@
#lang racket
(require math (only-in srfi/27 random-real))
(define (histogram n xs Δx)
(define (r x) (~r x #:precision 1 #:min-width 3))
(define (len count) (exact-floor (/ (* count 200) n)))
(for ([b (bin-samples (range 0 1 Δx) <= xs)])
(displayln (~a (r (sample-bin-min b)) "-" (r (sample-bin-max b)) ": "
(make-string (len (length (sample-bin-values b))) #\*)))))
(define (task n)
(define xs (for/list ([_ n]) (random-real)))
(displayln (~a "Number of samples: " n))
(displayln (~a "Mean: " (mean xs)))
(displayln (~a "Standard deviance: " (stddev xs)))
(histogram n xs 0.1)
(newline))
(task 100)
(task 1000)
(task 10000)

10
Task/Statistics-Basic/Raku/statistics-basic.raku Normal file
View file

@ -0,0 +1,10 @@
for 100, 1_000, 10_000 -> $N {
say "size: $N";
my @data = rand xx $N;
printf "mean: %f\n", my $mean = $N R/ [+] @data;
printf "stddev: %f\n", sqrt
$mean**2 R- $N R/ [+] @data »**» 2;
printf "%.1f %s\n", .key, '=' x (500 * .value.elems / $N)
for sort @data.classify: (10 * *).Int / 10;
say '';
}

38
Task/Statistics-Basic/Ring/statistics-basic.ring Normal file
View file

@ -0,0 +1,38 @@
# Project : Statistics/Basic
decimals(9)
sample(100)
sample(1000)
sample(10000)
func sample(n)
samp = list(n)
for i =1 to n
samp[i] =random(9)/10
next
sum = 0
sumSq = 0
for i = 1 to n
sum = sum + samp[i]
sumSq = sumSq +pow(samp[i],2)
next
see n + " Samples used." + nl
mean = sum / n
see "Mean = " + mean + nl
see "Std Dev = " + pow((sumSq /n -pow(mean,2)),0.5) + nl
bins2 = 10
bins = list(bins2)
for i = 1 to n
z = floor(bins2 * samp[i])
if z != 0
bins[z] = bins[z] +1
ok
next
for b = 1 to bins2
see b + " " + nl
for j = 1 to floor(bins2 *bins[b]) /n *70
see "*"
next
see nl
next
see nl

20
Task/Statistics-Basic/Ruby/statistics-basic.rb Normal file
View file

@ -0,0 +1,20 @@
def generate_statistics(n)
sum = sum2 = 0.0
hist = Array.new(10, 0)
n.times do
r = rand
sum += r
sum2 += r**2
hist[(10*r).to_i] += 1
end
mean = sum / n
stddev = Math::sqrt((sum2 / n) - mean**2)
puts "size: #{n}"
puts "mean: #{mean}"
puts "stddev: #{stddev}"
hist.each_with_index {|x,i| puts "%.1f:%s" % [0.1*i, "=" * (70*x/hist.max)]}
puts
end
[100, 1000, 10000].each {|n| generate_statistics n}

42
Task/Statistics-Basic/Run-BASIC/statistics-basic.basic Normal file
View file

@ -0,0 +1,42 @@
call sample 100
call sample 1000
call sample 10000
end
sub sample n
dim samp(n)
for i =1 to n
samp(i) =rnd(1)
next i
' calculate mean, standard deviation
sum = 0
sumSq = 0
for i = 1 to n
sum = sum + samp(i)
sumSq = sumSq + samp(i)^2
next i
print n; " Samples used."
mean = sum / n
print "Mean = "; mean
print "Std Dev = "; (sumSq /n -mean^2)^0.5
'------- Show histogram
bins = 10
dim bins(bins)
for i = 1 to n
z = int(bins * samp(i))
bins(z) = bins(z) +1
next i
for b = 0 to bins -1
print b;" ";
for j = 1 to int(bins *bins(b)) /n *70
print "*";
next j
print
next b
print
end sub

70
Task/Statistics-Basic/Rust/statistics-basic.rust Normal file
View file

@ -0,0 +1,70 @@
#![feature(iter_arith)]
extern crate rand;
use rand::distributions::{IndependentSample, Range};
pub fn mean(data: &[f32]) -> Option<f32> {
if data.is_empty() {
None
} else {
let sum: f32 = data.iter().sum();
Some(sum / data.len() as f32)
}
}
pub fn variance(data: &[f32]) -> Option<f32> {
if data.is_empty() {
None
} else {
let mean = mean(data).unwrap();
let mut sum = 0f32;
for &x in data {
sum += (x - mean).powi(2);
}
Some(sum / data.len() as f32)
}
}
pub fn standard_deviation(data: &[f32]) -> Option<f32> {
if data.is_empty() {
None
} else {
let variance = variance(data).unwrap();
Some(variance.sqrt())
}
}
fn print_histogram(width: u32, data: &[f32]) {
let mut histogram = [0; 10];
let len = histogram.len() as f32;
for &x in data {
histogram[(x * len) as usize] += 1;
}
let max_frequency = *histogram.iter().max().unwrap() as f32;
for (i, &frequency) in histogram.iter().enumerate() {
let bar_width = frequency as f32 * width as f32 / max_frequency;
print!("{:3.1}: ", i as f32 / len);
for _ in 0..bar_width as usize {
print!("*");
}
println!("");
}
}
fn main() {
let range = Range::new(0f32, 1f32);
let mut rng = rand::thread_rng();
for &number_of_samples in [1000, 10_000, 1_000_000].iter() {
let mut data = vec![];
for _ in 0..number_of_samples {
let x = range.ind_sample(&mut rng);
data.push(x);
}
println!(" Statistics for sample size {}", number_of_samples);
println!("Mean: {:?}", mean(&data));
println!("Variance: {:?}", variance(&data));
println!("Standard deviation: {:?}", standard_deviation(&data));
print_histogram(40, &data);
}
}

21
Task/Statistics-Basic/Scala/statistics-basic.scala Normal file
View file

@ -0,0 +1,21 @@
def mean(a:Array[Double])=a.sum / a.size
def stddev(a:Array[Double])={
val sum = a.fold(0.0)((a, b) => a + math.pow(b,2))
math.sqrt((sum/a.size) - math.pow(mean(a),2))
}
def hist(a:Array[Double]) = {
val grouped=(SortedMap[Double, Array[Double]]() ++ (a groupBy (x => math.rint(x*10)/10)))
grouped.map(v => (v._1, v._2.size))
}
def printHist(a:Array[Double])=for((g,v) <- hist(a)){
println(s"$g: ${"*"*(205*v/a.size)} $v")
}
for(n <- Seq(100,1000,10000)){
val a = Array.fill(n)(Random.nextDouble)
println(s"$n numbers")
println(s"Mean: ${mean(a)}")
println(s"StdDev: ${stddev(a)}")
printHist(a)
println
}

26
Task/Statistics-Basic/Sidef/statistics-basic.sidef Normal file
View file

@ -0,0 +1,26 @@
func generate_statistics(n) {
var(sum=0, sum2=0);
var hist = 10.of(0);
n.times {
var r = 1.rand;
sum += r;
sum2 += r**2;
hist[10*r] += 1;
}
var mean = sum/n;
var stddev = Math.sqrt(sum2/n - mean**2);
say "size: #{n}";
say "mean: #{mean}";
say "stddev: #{stddev}";
var max = hist.max;
hist.range.each {|i|
printf("%.1f:%s\n", 0.1*i, "=" * 70*hist[i]/max);
}
print "\n";
}
[100, 1000, 10000].each {|n| generate_statistics(n) }

10
Task/Statistics-Basic/Stata/statistics-basic.stata Normal file
View file

@ -0,0 +1,10 @@
. clear all
. set obs 100000
number of observations (_N) was 0, now 100,000
. gen x=runiform()
. summarize x
Variable | Obs Mean Std. Dev. Min Max
-------------+---------------------------------------------------------
x | 100,000 .4991874 .2885253 1.18e-06 .9999939
. hist x

27
Task/Statistics-Basic/Tcl/statistics-basic.tcl Normal file
View file

@ -0,0 +1,27 @@
package require Tcl 8.5
proc stats {size} {
set sum 0.0
set sum2 0.0
for {set i 0} {$i < $size} {incr i} {
set r [expr {rand()}]
incr histo([expr {int(floor($r*10))}])
set sum [expr {$sum + $r}]
set sum2 [expr {$sum2 + $r**2}]
}
set mean [expr {$sum / $size}]
set stddev [expr {sqrt($sum2/$size - $mean**2)}]
puts "$size numbers"
puts "Mean: $mean"
puts "StdDev: $stddev"
foreach i {0 1 2 3 4 5 6 7 8 9} {
# The 205 is a magic factor stolen from the Go solution
puts [string repeat "*" [expr {$histo($i)*205/int($size)}]]
}
}
stats 100
puts ""
stats 1000
puts ""
stats 10000

35
Task/Statistics-Basic/V-(Vlang)/statistics-basic-1.v Normal file
View file

@ -0,0 +1,35 @@
import rand
import math
fn main() {
sample(100)
sample(1000)
sample(10000)
}
fn sample(n int) {
// generate data
mut d := []f64{len: n}
for i in 0.. d.len {
d[i] = rand.f64()
}
// show mean, standard deviation
mut sum, mut ssq := f64(0), f64(0)
for s in d {
sum += s
ssq += s * s
}
println("$n numbers")
m := sum / f64(n)
println("Mean: $m")
println("Stddev: ${math.sqrt(ssq/f64(n)-m*m)}")
// show histogram
mut h := []int{len: 10}
for s in d {
h[int(s*10)]++
}
for c in h {
println("*".repeat(c*205/int(n)))
}
println('')
}

30
Task/Statistics-Basic/V-(Vlang)/statistics-basic-2.v Normal file
View file

@ -0,0 +1,30 @@
import rand
import math.stats
fn main() {
sample(100)
sample(1000)
sample(10000)
}
fn sample(n int) {
// generate data
mut d := []f64{len: n}
for i in 0.. d.len {
d[i] = rand.f64()
}
// show mean, standard deviation
println("$n numbers")
m := stats.mean<f64>(d)//sum / f64(n)
println("Mean: $m")
println("Stddev: ${stats.sample_stddev<f64>(d)}")
// show histogram
mut h := []int{len: 10}
for s in d {
h[int(s*10)]++
}
for c in h {
println("*".repeat(c*205/int(n)))
}
println('')
}

25
Task/Statistics-Basic/VBA/statistics-basic.vba Normal file
View file

@ -0,0 +1,25 @@
Option Base 1
Private Function mean(s() As Variant) As Double
mean = WorksheetFunction.Average(s)
End Function
Private Function standard_deviation(s() As Variant) As Double
standard_deviation = WorksheetFunction.StDev(s)
End Function
Public Sub basic_statistics()
Dim s() As Variant
For e = 2 To 4
ReDim s(10 ^ e)
For i = 1 To 10 ^ e
s(i) = Rnd()
Next i
Debug.Print "sample size"; UBound(s), "mean"; mean(s), "standard deviation"; standard_deviation(s)
t = WorksheetFunction.Frequency(s, [{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}])
For i = 1 To 10
Debug.Print Format((i - 1) / 10, "0.00");
Debug.Print "-"; Format(i / 10, "0.00"),
Debug.Print String$(t(i, 1) / (10 ^ (e - 2)), "X");
Debug.Print
Next i
Debug.Print
Next e
End Sub

24
Task/Statistics-Basic/Wren/statistics-basic.wren Normal file
View file

@ -0,0 +1,24 @@
import "random" for Random
import "/math" for Nums
var r = Random.new()
for (i in [100, 1000, 10000]) {
var a = List.filled(i, 0)
for (j in 0...i) a[j] = r.float()
System.print("For %(i) random numbers:")
System.print(" mean = %(Nums.mean(a))")
System.print(" std/dev = %(Nums.popStdDev(a))")
var scale = i / 100
System.print(" scale = %(scale) per asterisk")
var sums = List.filled(10, 0)
for (e in a) {
var f = (e*10).floor
sums[f] = sums[f] + 1
}
for (j in 0..8) {
sums[j] = (sums[j] / scale).round
System.print(" 0.%(j) - 0.%(j+1): %("*" * sums[j])")
}
sums[9] = 100 - Nums.sum(sums[0..8])
System.print(" 0.9 - 1.0: %("*" * sums[9])\n")
}

49
Task/Statistics-Basic/XPL0/statistics-basic.xpl0 Normal file
View file

@ -0,0 +1,49 @@
include xpllib; \for Print
func real Mean(X, N);
real X; int N;
real Sum; int I;
[Sum:= 0.;
for I:= 0 to N-1 do
Sum:= Sum + X(I);
return Sum/float(N);
];
func real StdDev(X, N, Mean);
real X; int N; real Mean;
real Sum; int I;
[Sum:= 0.;
for I:= 0 to N-1 do
Sum:= Sum + sq(X(I) - Mean);
return sqrt(Sum/float(N));
];
int Size, J, K, Sums(10), Scale;
real A, M;
[Size:= 100;
repeat A:= RlRes(Size);
for J:= 0 to Size-1 do
A(J):= float(Ran(1_000_000)) / 1e6;
Print("For %d random numbers:\n", Size);
M:= Mean(A, Size);
Print(" mean = %1.9f\n", M);
Print(" stddev = %1.9f\n", StdDev(A, Size, M));
Scale:= Size / 100;
Print(" scale = %d per asterisk\n", Scale);
for J:= 0 to 10-1 do Sums(J):= 0;
for J:= 0 to Size-1 do
[K:= fix(Floor(A(J)*10.));
Sums(K):= Sums(K)+1;
];
for J:= 0 to 8 do
[Sums(J):= Sums(J) / Scale;
Print(" 0.%d - 0.%d: ", J, J+1);
for K:= 1 to Sums(J) do ChOut(0, ^*);
CrLf(0);
];
Print(" 0.9 - 1.0: ");
for K:= 1 to Sums(9)/Scale do ChOut(0, ^*);
CrLf(0); CrLf(0);
Size:= Size * 10;
until Size > 10_000;
]

41
Task/Statistics-Basic/Yabasic/statistics-basic.basic Normal file
View file

@ -0,0 +1,41 @@
sample ( 100)
sample ( 1000)
sample (10000)
end
sub sample (n)
dim samp(n)
for i = 1 to n
samp(i) = ran(1)
next i
// calculate mean, standard deviation
sum = 0
sumSq = 0
for i = 1 to n
sum = sum + samp(i)
sumSq = sumSq + samp(i) ^ 2
next i
print "Sample size ", n
mean = sum / n
print "\n Mean = ", mean
print " Std Dev = ", (sumSq / n - mean ^ 2) ^ 0.5
print
//------- Show histogram
bins = 10
dim bins(bins)
for i = 1 to n
z = int(bins * samp(i))
bins(z) = bins(z) + 1
next i
for b = 0 to bins -1
print " ", b, " : ";
for j = 1 to int(bins * bins(b)) / n * 70
print "*";
next j
print
next b
print
end sub

4
Task/Statistics-Basic/Zkl/statistics-basic-1.zkl Normal file
View file

@ -0,0 +1,4 @@
fcn mean(ns) { ns.sum(0.0)/ns.len() }
fcn stdDev(ns){
m:=mean(ns); (ns.reduce('wrap(p,n){ x:=(n-m); p+x*x },0.0)/ns.len()).sqrt()
}

9
Task/Statistics-Basic/Zkl/statistics-basic-2.zkl Normal file
View file

@ -0,0 +1,9 @@
reg ns;
foreach n in (T(100,1000,10000)){
ns=(0).pump(n,List,(0.0).random.fp(1.0));
println("N:%,6d mean:%.5f std dev:%.5f".fmt(n,mean(ns),stdDev(ns)));
}
foreach r in ([0.0 .. 0.9, 0.1]){ // using the last data set (10000 randoms)
n:=ns.filter('wrap(x){ r<=x<(r+0.1) }).len();
println("%.2f..%.2f:%4d%s".fmt(r,r+0.1,n,"*"*(n/20)));
}

13
Task/Statistics-Basic/Zkl/statistics-basic-3.zkl Normal file
View file

@ -0,0 +1,13 @@
var pipe=Thread.Pipe(); // used to connect the two threads
fcn{ while(1){ pipe.write((0.0).random(1.0)) } }.launch(); // generator
fcn{ // consumer/calculator
N:=0; M:=SD:=sum:=ssum:=0.0;
while(1){
x:=pipe.read(); N+=1; sum+=x; ssum+=x*x;
M=sum/N; SD=(ssum/N - M*M).sqrt();
if(0==N%100000)
println("N:%,10d mean:%.5f std dev:%.5f".fmt(N,M,SD));
}
}.launch();
Atomic.sleep(60*60); // wait because exiting the VM kills the threads