Statistics/Basic: Difference between revisions

{{trans|Python}}

V mean = sum(numbers) / numbers.len

V sd = (sum(numbers.map(n -> (n - @mean) ^ 2)) / numbers.len) ^ 0.5

V (sd, mean) = sd_mean(n)

print(‘ sd: #.6, mean: #.6’.format(sd, mean))

{{out}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

DEFINE SIZE="10000"

PutE() PutE()

Test(10000)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Statistics_basic.png Screenshot from Atari 8-bit computer]

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

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:

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

generate_statistics = (n) ->

hist = {}

display_statistics n, mean, stddev, hist

{{out}}

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

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

<pre>

=={{header|FreeBASIC}}==

Randomize

Print

Print "Press any key to quit"

{{out}}

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

For the sake of illustration, we will use /dev/urandom encapsulated in a shell function:

function prng {

cat /dev/urandom | tr -cd '0-9' | fold -w "$2" | head -n "$1"

'''basicStats.jq'''

# $keys should be an array of all the potential bucket names (possibly integers)

# in the order to be used for display:

stddev: \(.stddev)

Histogram dividing [0,1] into 10 equal intervals:",

'''Driver Script''' (e.g. bash)

echo "Basic statistics for $n PRNs in [0,1]"

prng $n 10 | jq -nrR -f basicStats.jq

echo

{{out}}

<pre>

=={{header|Jsish}}==

"use strict";

0

=!EXPECTEND!=

{{out}}

=={{header|Julia}}==

function hist(numbers)

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

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

Be aware that the PRNG in LB has a SLIGHT bias.

call sample 100

call sample 1000

print

end sub

100000 data terms used.

Mean =0.49870232

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

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

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

=={{header|MiniScript}}==

A little Stats class is defined that can calculate mean and standard deviation for a stream of numbers (of arbitrary size, so yes, this would work for a trillion numbers just as well as for one).

Stats.count = 0

Stats.sum = 0

print "Mean: " + st.mean + " Standard Deviation: " + st.stddev

st.histogram

{{out}}

<pre>Samples: 100

=={{header|Nim}}==

The standard module “stats” provides procedures to compute the statistical moments. It is possible to compute them either on a list of values or incrementally using an object <code>RunningStat</code>. In the following program, we use the first method for the 100 numbers samples and we draw the histogram. For the 1_000, 10_000, 100_000 and 1_000_000 samples, we use the second method which avoids to store the values (but don’t draw the histogram).

proc drawHistogram(ns: seq[float]) =

rs.push(n)

echo &"μ = {rs.mean:.12f} σ = {rs.standardDeviation:.12f}"

{{out}}

<pre>For 100 numbers:

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

vecsum(v)/#v

};

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>

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

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

{{Out}}

<pre style="float:left; font-size: 10px">

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

<pre>

{{trans|Liberty BASIC}}

Changes were made from the Liberty BASIC version to normalize the histogram as well as implement a random float function.

#RNG_max_resolution = 2147483647

ProcedureReturn Random(#RNG_max_resolution) / #RNG_max_resolution

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>100 data terms used.

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

(formerly Perl 6)

{{Works with|rakudo|2018.03}}

say "size: $N";

my @data = rand xx $N;

for sort @data.classify: (10 * *).Int / 10;

say '';

{{out}}

<pre>size: 100

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

=={{header|Ruby}}==

sum = sum2 = 0.0

hist = Array.new(10, 0)

end

{{out}}

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

call sample 1000

call sample 10000

next b

print

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

100 Samples used.

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

var(sum=0, sum2=0);

var hist = 10.of(0);

}

{{out}}

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

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

=={{header|Vlang}}==

{{trans|go}}

import math

}

println('')

{{out}}

</pre>

Or use standard math.stats module

import math.stats

}

println('')

{{out}}

Similar to above

=={{header|Wren}}==

{{libheader|Wren-math}}

import "/math" for Nums

sums[9] = 100 - Nums.sum(sums[0..8])

System.print(" 0.9 - 1.0: %("*" * sums[9])\n")

{{out}}

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