Statistics/Basic: Difference between revisions

<br><hr>

 

 

===A plain solution for moderate sample sizes===

 

Ada.Numerics.Generic_Elementary_Functions;

 

TIO.New_Line;

Put_Mean_Et_Al(Sample_Size => N, Val_Sum => Val_Sum, Square_Sum => Squ_Sum);

{{out}} from a few sample runs:

<pre>> ./basic_stat 1000

This is the modified program

 

Ada.Numerics.Generic_Elementary_Functions;

 

Put_Mean_Et_Al(Sample_Size => N,

Val_Sum => Float(Val_Sum), Square_Sum => Float(Squ_Sum));

 

{{out}} for sample size 10^12 took one night on my PC:

 

The same program should still work fine for sample size 10^18, but I'll need my PC in the meantime. ;-)

 

=={{header|C}}==

Sample code.

#include <stdlib.h>

#include <math.h>

}

}

 

=={{header|C sharp|C#}}==

{{libheader|Math.Net}}

using MathNet.Numerics.Statistics;

 

Run(10000);

}

{{out}}

<pre>Sample size: 100

 

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

#include <random>

#include <vector>

std::cout << "Standard deviation is " << stddev << " !" << std::endl ;

return 0 ;

{{out}}

<pre>./statistics 100

 

=={{header|CoffeeScript}}==

hist = {}

 

for n in [100, 1000, 10000, 1000000]

[n, mean, stddev, hist] = generate_statistics n

{{out}}

-- Stats for sample size 100

mean: 0.5058459933893755

=={{header|D}}==

{{trans|Python}}

std.range, std.exception;

 

}

}

Compile with "-version=statistics_basic_main" to run the main function.

{{out}}

 

=={{header|Dart}}==

* 1) Square root function : Math.sqrt(x)

* 2) Power function : Math.pow(base, exponent)

print('');

}

{{out}}

<pre>

 

</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def basic(n) do

{sum, sum2, hist} = generate(n)

Enum.each([100,1000,10000], fn n ->

Statistics.basic(n)

 

{{out}}

 

=={{header|Factor}}==

math.functions math.order math.statistics prettyprint random

sequences sequences.deep sequences.repeating ;

{ 100 1,000 10,000 } [ stats ] each ;

{{out}}

<pre>

{{works with|Fortran|95 and later}}

This version will handle numbers as large as 1 trillion or more if you are prepared to wait long enough

implicit none

end do

{{out}}

Mean : 0.507952672404959

Stddev : 0.290452178516586

0.8: =================================================

0.9: ==================================================

 

=={{header|Go}}==

 

import (

}

fmt.Println()

{{out}}

<pre>

 

The following runs comfortably on a simulated data size of 10 million. To scale to a trillion, and to use real data, you would want to use a technique like [[Distributed_programming#Go]] to distribute work across multiple computers, and on each computer, use a technique like [[Parallel_calculations#Go]] to distribute work across multiple cores within each computer. You would tune parameters like the constant <tt>threshold</tt> in the code below to optimize cache performance.

 

import (

}

return

{{out}}

<pre>

 

=={{header|Haskell}}==

import System.Random (randomRs, newStdGen)

import Control.Monad (zipWithM_)

 

-- To avoid Wiki formatting issue

{{out}}

<pre>./Statistics 100

=={{header|Hy}}==

 

[numpy.random [random]]

[numpy [mean std]]

 

(plt.hist (random 1000))

 

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

In this example,

 

 

W := 50 # avg width for histogram bar

write(right(real(i)/*H,5)," : ",repl("*",integer(*H*50./N*H[i])))

}

 

{{out}}

 

J has library routines to compute mean and standard deviation:

(mean,stddev) 1000 ?@$ 0

0.484669 0.287482

0.503642 0.290777

(mean,stddev) 100000 ?@$ 0

 

And, for a histogram:

 

require'plot'

 

but these are not quite what is being asked for here.

Instead:

 

 

meanstddevP=: 3 :0

smoutput (<.300*h%y) #"0 '#'

(s%y) , %:t%y

 

Example use:

 

#############################

####################################

##############################

#############################

 

(That said, note that these numbers are random, so reported standard deviation will vary with the random sample being tested.)

Translation of [[Statistics/Basic#Python|Python]] via [[Statistics/Basic#D|D]]

{{works with|Java|8}}

import static java.util.Arrays.stream;

import static java.util.stream.Collectors.joining;

}

}

<pre>10 numbers:

Mean: 0.564409, SD: 0.249601

0.8: **************************************************

0.9: **************************************************</pre>

 

=={{header|Julia}}==

 

maxwidth = 50

h = fill(0, 10)

@printf("μ: %8.6f; σ: %8.6f\n", mean(n), std(n))

hist(n)

 

{{out}}

Using the "mu" (mean) and "sd" (standard deviation) functions from the

Klong statistics library:

.l("nstat.kg")

bar::{x{x;.d("*")}:*0;.p("")}

plot(1000)

plot(10000)

{{out}}

<pre>

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

val rand = java.util.Random()

val sampleSizes = intArrayOf(100, 1_000, 10_000, 100_000)

for (sampleSize in sampleSizes) basicStats(sampleSize)

Sample run:

{{out}}

 

=={{header|Lasso}}==

if(#a->size) => {

local(mean = (with n in #a sum #n) / #a->size)

histogram(#n)

'\r\r'

 

{{out}}

0.9: ++++++++++++++++++++++++++++++++++++++++++++++++++

1.0: ++++++++++++++++++++++++</pre>

 

=={{header|Lua}}==

The standard deviation seems to converge to around 0.28. I expect there's a good reason for this, though it's entirely beyond me.

math.randomseed(os.time())

 

showStats(10 ^ power)

end

 

=={{header|Maple}}==

The following samples 100 uniformly distributed numbers between 0 and 1:

X_100 := Sample( Uniform(0,1), 100 );

Mean( X_100 );

StandardDeviation( X_100 );

It is also possible to make a procedure that outputs the mean, standard deviation, and a histogram for a given number of random uniformly distributed numbers:

local data;

data := Sample( Uniform(0,1), n );

return Statistics:-Histogram( data );

end proc:

 

BarChart[BinCounts[#,{0,1,.1}], Axes->False, BarOrigin->Left])&[(RandomReal[1,#])&[ n ]]

{{out}}

<pre>100 numbers, Mean : 0.478899, StandardDeviation : 0.322265

 

=={{header|MATLAB}} / {{header|Octave}}==

N = 0; S=0; S2 = 0;

binlist = 0:.1:1;

m = S/N; % mean

sd = sqrt(S2/N-mean*mean); % standard deviation

 

 

 

for n in ns:

inc h[pos]

 

let mx = max(h)

echo ""

echo ""

 

{{out}}

 

0.3: ++++++++++++++++++++++++++++++++++++++++++++++++++

 

 

 

 

=={{header|Oforth}}==

 

| l m std i nb |

 

i 0.1 + <<wjp(3, JUSTIFY_RIGHT, 2) " - " <<

StringBuffer new "*" <<n(nb) << cr

 

{{out}}

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

{{works with|PARI/GP|2.4.3 and above}}

};

stdev(v,mu="")={

show(100);

show(1000);

 

For versions before 2.4.3, define

my(pr=32*ceil(default(realprecision)*log(10)/log(4294967296))); \\ Current precision

random(2^pr)*1.>>pr

and use <code>rreal()</code> in place of <code>random(1.)</code>.

 

=={{header|Perl}}==

my $sum = 0;

my $sum_squares = 0;

print "*" x (30 * $histogram[$i] * @histogram/$n); # 30 stars expected per row

print "\n";

 

Usage: <pre>perl rand_statistics.pl (number of values)</pre>

0.8 - 0.9 : *******************************

0.9 - 1.0 : *******************************</pre>

 

=={{header|Phix}}==

{{trans|CoffeeScript}}

To do a trillion samples, I would change the existing generate loop into an inner 100_000_000 loop that still uses the fast native types, with everything outside that changed to bigatom, and of course add an outer loop which sums into them.

{{Out}}

-- Stats for sample size 100

mean: 0.530925

1.0: ========================================== 14

</pre>

-- Stats for sample size 1000

mean: 0.50576

1.0: ============================== 101

</pre>

-- Stats for sample size 10000

mean: 0.498831

1.0: ============================= 999

</pre>

-- Stats for sample size 1000000

mean: 0.499937

=={{header|PicoLisp}}==

The following has no limit on the number of samples. The 'statistics' function accepts an executable body 'Prg', which it calls repeatedly to get the samples.

(seed (time))

 

(rand 0 (dec 1.0)) )

(prinl) )

{{out}}

<pre>100 numbers

 

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

 

stats: procedure (values, mean, standard_deviation);

end;

 

{{out}}

.......

..............

1000 values: mean= 4.97079E-0001 stddev= 1.07871E-0005

10000 values: mean= 4.99119E-0001 stddev= 8.35870E-0005

 

=={{header|Python}}==

The second function, sd2 only needs to go once through the numbers and so can more efficiently handle large streams of numbers.

if numbers:

mean = sum(numbers) / len(numbers)

print(' Naive method: sd: %8.6f, mean: %8.6f' % sd1(n))

print(' Second method: sd: %8.6f, mean: %8.6f' % sd2(n))

 

{{out}}

=={{header|R}}==

The challenge of processing a trillion numbers is generating them in the first place. As the errors below show, allocating 7.5 TB for such a vector is simply impractical. The workaround is to generate them, process individual data points and then discard them. The downside in this case is the time.

#Generate the sets

a = runif(10,min=0,max=1)

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

Output

<pre>

 

=={{header|Racket}}==

#lang racket

(require math (only-in srfi/27 random-real))

(task 1000)

(task 10000)

{{out}}

<pre>

0.9- 1: *******************

</pre>

 

=={{header|REXX}}==

Twenty decimal digits are used for the calculations, but only half that (ten digits) are displayed in the output.

numeric digits 20 /*use twenty decimal digits precision, */

showDigs=digits()%2 /* ··· but only show ten decimal digits*/

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

{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 100 </tt>}}

<pre>

 

=={{header|Ring}}==

# Project : Statistics/Basic

 

next

see nl

Output:

<pre>

9

*********************************************************************

</pre>

 

=={{header|Ruby}}==

sum = sum2 = 0.0

hist = Array.new(10, 0)

end

 

{{out}}

mean: 0.5565132836634081

stddev: 0.30678831716883026

0.7:===================================================================

0.8:===================================================================

 

=={{header|Rust}}==

{{libheader|rand}}

extern crate rand;

 

print_histogram(40, &data);

}

{{out}}

<pre> Statistics for sample size 1000

 

=={{header|Scala}}==

def stddev(a:Array[Double])={

val sum = a.fold(0.0)((a, b) => a + math.pow(b,2))

printHist(a)

println

{{out}}

<pre>100 numbers

=={{header|Sidef}}==

{{trans|Ruby}}

n.times {

}

}

}

{{out}}

<pre style="height: 40ex; overflow: scroll">

size: 100

 

size: 1000

0.1:========================================================

0.3:========================================================

 

size: 10000

0.5:=================================================================

0.6:===============================================================

0.8:==================================================================

</pre>

 

For a uniform distribution on [0,1], the mean is 1/2 and the variance is 1/12 (hence the standard deviation is 0.28867513). With a large sample, one can check the convergence to these values.

 

. set obs 100000

number of observations (_N) was 0, now 100,000

-------------+---------------------------------------------------------

x | 100,000 .4991874 .2885253 1.18e-06 .9999939

 

=={{header|Tcl}}==

proc stats {size} {

set sum 0.0

stats 1000

puts ""

{{out}}

<pre>

 

=={{header|VBA}}==

Private Function mean(s() As Variant) As Double

mean = WorksheetFunction.Average(s)

Debug.Print

Next e

<pre>sample size 100 mean 0,472405961751938 standard deviation 0,260463885857138

0,00-0,10 XXXXXX

0,80-0,90 XXXXXXXXXX

0,90-1,00 XXXXXXXXXX</pre>

=={{header|zkl}}==

fcn stdDev(ns){

m:=mean(ns); (ns.reduce('wrap(p,n){ x:=(n-m); p+x*x },0.0)/ns.len()).sqrt()

foreach n in (T(100,1000,10000)){

ns=(0).pump(n,List,(0.0).random.fp(1.0));

n:=ns.filter('wrap(x){ r<=x<(r+0.1) }).len();

println("%.2f..%.2f:%4d%s".fmt(r,r+0.1,n,"*"*(n/20)));

(0.0).random(1.0) generates a [uniform] random number between 0 (inclusive) and 1 (exclusive).

{{out}}

</pre>

For the extra credit, pretend we have a device that spews random numbers in the range [0..1) forever. We connect this device to a measuring device that calculates mean and std deviation, printing results on a regular basis.

fcn{ while(1){ pipe.write((0.0).random(1.0)) } }.launch(); // generator

fcn{ // consumer/calculator

}.launch();

 

{{out}}

<pre>