Statistics/Basic: Difference between revisions
m
→{{header|Wren}}: Minor tidy
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
m (→{{header|Wren}}: Minor tidy) |
||
| (17 intermediate revisions by 9 users not shown) | |||
Line 37:
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F sd_mean(numbers)
V mean = sum(numbers) / numbers.len
Line 231 ⟶ 230:
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Statistics_basic.png Screenshot from Atari 8-bit computer]
<pre>100: m=.5372941127 sd=.2901337976
0.0x: *************** 8
0.1x: ********** 5
Line 254 ⟶ 252:
0.7x: *********************** 960
0.8x: ************************ 979
0.9x: ************************ 975</pre>
=={{header|Ada}}==
===A plain solution for moderate sample sizes===
Line 324 ⟶ 320:
Put_Mean_Et_Al(Sample_Size => N, Val_Sum => Val_Sum, Square_Sum => Squ_Sum);
end Basic_Stat;</syntaxhighlight>
{{out}} from a few sample runs:
<pre>> ./basic_stat 1000
Line 558 ⟶ 553:
The same program should still work fine for sample size 10^18, but I'll need my PC in the meantime. ;-)
=={{header|ALGOL 68}}==
Suitable for the moderate sample sizes millions or billions probably - not suitable for e.g.: a trillion samples (with early 21st century hardware).
<syntaxhighlight lang="algol68">
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
</syntaxhighlight>
{{out}}
<pre>
Sample size: 100, mean: 0.5092, stddev: 0.2783
0.00: ==================== (10)
0.10: ==================== (10)
0.20: ========== (5)
0.30: ======================== (12)
0.40: ======================== (12)
0.50: ================ (8)
0.60: ================================ (16)
0.70: ================ (8)
0.80: ======================== (12)
0.90: ============== (7)
Sample size: 1000, mean: 0.4989, stddev: 0.2855
0.00: ========================== (92)
0.10: =============================== (110)
0.20: =========================== (97)
0.30: ============================ (100)
0.40: ============================ (102)
0.50: ========================== (94)
0.60: ================================ (115)
0.70: ========================== (92)
0.80: =========================== (98)
0.90: ============================ (100)
Sample size: 10000, mean: 0.5011, stddev: 0.2863
0.00: ============================= (942)
0.10: ============================== (996)
0.20: ================================ (1057)
0.30: ============================= (968)
0.40: =============================== (1028)
0.50: ============================== (1000)
0.60: =============================== (1008)
0.70: =============================== (1019)
0.80: ============================== (1003)
0.90: ============================== (979)
Sample size: 100000, mean: 0.4996, stddev: 0.2881
0.00: =============================== (9917)
0.10: ================================ (10136)
0.20: =============================== (9936)
0.30: =============================== (9850)
0.40: ================================ (10123)
0.50: ================================ (10139)
0.60: ================================ (10167)
0.70: =============================== (9840)
0.80: =============================== (9905)
0.90: =============================== (9987)
</pre>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="c">
#include <basico.h>
#define TOTAL_BINES 10
algoritmo
/* verifica y obtiene argumento: tamaño de muestra*/
tamaño muestra=0
//obtener total argumentos
//es distinto a '2', entonces{ terminar }
//obtener parámetro numérico(2), mover a 'tamaño muestra'
/* algo menos natural, pero más claro para una mente formal: */
obtener total argumentos
si ' es distinto a( 2 ) '
terminar
sino
guardar ' parám numérico(2)' en 'tamaño muestra'
fin si
/* establece la escala para desplegar barras */
escala = 1.0
si ' #(tamaño muestra > 50) '
#( escala = 50.0 / tamaño muestra )
fin si
/* Generar muestra de tamaño "tamaño muestra" */
dimensionar con ( tamaño muestra) matriz aleatoria entera ( 10, muestra )
decimales '3'
/* Genera tabla de clases con 10 bines */
tabla de clases=0
bines(TOTAL_BINES, muestra), mover a 'tabla de clases'
/* Imprime tabla de clases */
ir a subrutina( desplegar tabla de clases)
/* Calcula promedio según tabla de clases */
promedio tabla=0, FREC=0, MC=0
ir a subrutina ( calcular promedio de tabla de clases )
/* Calcula desviación estándar y varianza */
desviación estándar=0, varianza=0
ir a subrutina ( calcular desviación estándar y varianza )
/* Calcula promedio de la muestra completa e imprime medidas */
ir a subrutina ( desplegar medidas y medias )
/* Construye barras */
tamaño barras=0, barras=0
ir a subrutina( construir barras para histograma ), mover a 'barras'
/* arma histograma de salida */
sMC=0
ir a subrutina( construir y desplegar histograma )
terminar
subrutinas
desplegar tabla de clases:
token.separador '"\t"'
imprimir '#(utf8("Tamaño de la muestra = ")), tamaño muestra,NL,NL,\
#(utf8("Números entre 0 y 10\n\n")),\
" --RANGO--\tM.DE C.\tFREC.\tF.R\t F.A.\tF.R.A.\n",\
"-----------------------------------------------------\n"'
imprimir 'justificar derecha(5,#(string(tabla de clases))), NL'
retornar
desplegar medidas y medias:
promedio muestra=0
muestra, promediar, mover a 'promedio muestra'
imprimir ' "Media de la muestra = ", promedio muestra, NL,\
"Media de la tabla = ", promedio tabla, NL,\
"Varianza = ", varianza, NL,\
#(utf8("Desviación estandar = ")), desviación estándar,NL'
retornar
construir barras para histograma:
#(tamaño barras = int(FREC * escala * 5))
dimensionar con (TOTAL_BINES) matriz rellena ("*", barras)
#(barras = replicate( barras, tamaño barras))
retornar ' barras '
construir y desplegar histograma:
#(sMC = string(MC))
unir columnas( sMC, sMC, justificar derecha(5,#(string(FREC))), barras )
/* Imprime histograma */
token.separador '" "'
imprimir ( " M.C. FREC.\n-----------\n",\
sMC,NL )
retornar
calcular promedio de tabla de clases:
//[1:filasde(tabla de clases), 3] coger (tabla de clases), mover a 'MC'
//[1:filasde(tabla de clases), 4] coger (tabla de clases), mover a 'FREC'
/* un poco menos natural, pero más claro para una mente formal: */
#basic{
MC = tabla de clases[ 1:TOTAL_BINES, 3]
FREC = tabla de clases[ 1:TOTAL_BINES, 4]
}
borrar intervalo
multiplicar(MC,FREC), calcular sumatoria, dividir entre (tamaño muestra),
mover a 'promedio tabla'
retornar
calcular desviación estándar y varianza:
restar( MC, promedio tabla), elevar al cuadrado, por (FREC),
calcular sumatoria, dividir entre(tamaño muestra), copiar en 'varianza'
calcular raíz, mover a 'desviación estándar'
retornar
</syntaxhighlight>
{{out}}
<pre>
$ hopper3 basica/estat.bas 100
Tamaño de la muestra = 100
Números entre 0 y 10
--RANGO-- M.DE C. FREC. F.R F.A. F.R.A.
-----------------------------------------------------
0 1 0.500 12 0.120 12 0.120
1 2 1.500 7 0.070 19 0.190
2 3 2.500 9 0.090 28 0.280
3 4 3.500 14 0.140 42 0.420
4 5 4.500 14 0.140 56 0.560
5 6 5.500 3 0.030 59 0.590
6 7 6.500 8 0.080 67 0.670
7 8 7.500 11 0.110 78 0.780
8 9 8.500 7 0.070 85 0.850
9 10 9.500 15 0.150 100 1.000
Media de la muestra = 4.540
Media de la tabla = 5.040
Varianza = 8.969
Desviación estandar = 2.995
M.C. FREC.
-----------
0.500 12 ******************************
1.500 7 *****************
2.500 9 **********************
3.500 14 ***********************************
4.500 14 ***********************************
5.500 3 *******
6.500 8 ********************
7.500 11 ***************************
8.500 7 *****************
9.500 15 *************************************
$ hopper3 basica/estat.bas 1000
Tamaño de la muestra = 1000
Números entre 0 y 10
--RANGO-- M.DE C. FREC. F.R F.A. F.R.A.
-----------------------------------------------------
0 1 0.500 87 0.087 87 0.087
1 2 1.500 94 0.094 181 0.181
2 3 2.500 109 0.109 290 0.290
3 4 3.500 109 0.109 399 0.399
4 5 4.500 95 0.095 494 0.494
5 6 5.500 99 0.099 593 0.593
6 7 6.500 91 0.091 684 0.684
7 8 7.500 100 0.100 784 0.784
8 9 8.500 106 0.106 890 0.890
9 10 9.500 110 0.110 1000 1.000
Media de la muestra = 4.598
Media de la tabla = 5.098
Varianza = 8.235
Desviación estandar = 2.870
M.C. FREC.
-----------
0.500 87 *********************
1.500 94 ***********************
2.500 109 ***************************
3.500 109 ***************************
4.500 95 ***********************
5.500 99 ************************
6.500 91 **********************
7.500 100 *************************
8.500 106 **************************
9.500 110 ***************************
$ hopper3 basica/estat.bas 10000
Tamaño de la muestra = 10000
Números entre 0 y 10
--RANGO-- M.DE C. FREC. F.R F.A. F.R.A.
-----------------------------------------------------
0 1 0.500 1039 0.104 1039 0.104
1 2 1.500 1014 0.101 2053 0.205
2 3 2.500 1005 0.101 3058 0.306
3 4 3.500 976 0.098 4034 0.403
4 5 4.500 949 0.095 4983 0.498
5 6 5.500 995 0.100 5978 0.598
6 7 6.500 1039 0.104 7017 0.702
7 8 7.500 1009 0.101 8026 0.803
8 9 8.500 992 0.099 9018 0.902
9 10 9.500 982 0.098 10000 1.000
Media de la muestra = 4.479
Media de la tabla = 4.979
Varianza = 8.310
Desviación estandar = 2.883
M.C. FREC.
-----------
0.500 1039 *************************
1.500 1014 *************************
2.500 1005 *************************
3.500 976 ************************
4.500 949 ***********************
5.500 995 ************************
6.500 1039 *************************
7.500 1009 *************************
8.500 992 ************************
9.500 982 ************************
$ hopper3 basica/estat.bas 100000
Tamaño de la muestra = 100000
Números entre 0 y 10
--RANGO-- M.DE C. FREC. F.R F.A. F.R.A.
-----------------------------------------------------
0 1 0.500 10139 0.101 10139 0.101
1 2 1.500 10025 0.100 20164 0.202
2 3 2.500 9990 0.100 30154 0.302
3 4 3.500 10021 0.100 40175 0.402
4 5 4.500 9880 0.099 50055 0.501
5 6 5.500 10054 0.101 60109 0.601
6 7 6.500 9961 0.100 70070 0.701
7 8 7.500 10144 0.101 80214 0.802
8 9 8.500 9773 0.098 89987 0.900
9 10 9.500 10013 0.100 100000 1.000
Media de la muestra = 4.489
Media de la tabla = 4.989
Varianza = 8.264
Desviación estandar = 2.875
M.C. FREC.
-----------
0.500 10139 **************************************************
1.500 10025 **************************************************
2.500 9990 *************************************************
3.500 10021 **************************************************
4.500 9880 *************************************************
5.500 10054 **************************************************
6.500 9961 *************************************************
7.500 10144 **************************************************
8.500 9773 ************************************************
9.500 10013 **************************************************
</pre>
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
{{works with|MSX BASIC}}
{{trans|Chipmunk Basic}}
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|QBasic}}
{{trans|Yabasic}}
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">' 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</syntaxhighlight>
{{out}}
<pre>Sample size 100
Mean 0.485580 SD 0.269003
0.00 : 7 *******
0.10 : 10 **********
0.20 : 12 ************
0.30 : 17 *****************
0.40 : 8 ********
0.50 : 10 **********
0.60 : 11 ***********
0.70 : 9 *********
0.80 : 9 *********
0.90 : 7 *******
Sample size 1000
Mean 0.504629 SD 0.292029
0.00 : 99 **************************************************
0.10 : 99 **************************************************
0.20 : 93 ***********************************************
0.30 : 108 ******************************************************
0.40 : 101 ***************************************************
0.50 : 97 *************************************************
0.60 : 90 *********************************************
0.70 : 110 *******************************************************
0.80 : 102 ***************************************************
0.90 : 101 ***************************************************
Sample size 10000
Mean 0.500027 SD 0.290618
0.00 : 1039 ****************************************************
0.10 : 997 **************************************************
0.20 : 978 *************************************************
0.30 : 988 *************************************************
0.40 : 998 **************************************************
0.50 : 959 ************************************************
0.60 : 1037 ****************************************************
0.70 : 1004 **************************************************
0.80 : 965 ************************************************
0.90 : 1035 ****************************************************
Sample size 100000
Mean 0.499503 SD 0.288730
0.00 : 10194 ***************************************************
0.10 : 9895 *************************************************
0.20 : 9875 *************************************************
0.30 : 9922 **************************************************
0.40 : 10202 ***************************************************
0.50 : 9981 **************************************************
0.60 : 10034 **************************************************
0.70 : 10012 **************************************************
0.80 : 9957 **************************************************
0.90 : 9928 **************************************************</pre>
==={{header|GW-BASIC}}===
{{works with|Applesoft BASIC}}
{{works with|Chipmunk Basic}}
{{works with|PC-BASIC|any}}
{{works with|MSX BASIC}}
{{trans|Chipmunk Basic}}
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
==={{header|Liberty BASIC}}===
Be aware that the PRNG in LB has a SLIGHT bias.
<syntaxhighlight lang="lb">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</syntaxhighlight>
{{out}}
<pre> 100000 data terms used.
Mean =0.49870232
Stddev =0.28926563
######################################################################
######################################################################
######################################################################
######################################################################
#####################################################################
#####################################################################
#####################################################################
#####################################################################
######################################################################
#####################################################################</pre>
==={{header|MSX Basic}}===
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
==={{header|PureBasic}}===
{{trans|Liberty BASIC}}
Changes were made from the Liberty BASIC version to normalize the histogram as well as implement a random float function.
<syntaxhighlight lang="purebasic">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</syntaxhighlight>
{{out}}
<pre>100 data terms used.
Mean =0.4349198639
Stddev =-0.1744846404
#########################################################
#########################################
################################
#################################################################
################################
#####################################################
######################################################################
################
########################
################
1000 data terms used.
Mean =0.4960154891
Stddev =-0.1691310555
###############################################################
#######################################################
#############################################################
######################################################################
##########################################################
##############################################################
####################################################################
###############################################################
#############################################################
#####################################################
10000 data terms used.
Mean =0.5042046309
Stddev =-0.1668083966
##################################################################
################################################################
##################################################################
####################################################################
################################################################
######################################################################
####################################################################
###################################################################
####################################################################
####################################################################</pre>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
{{trans|Yabasic}}
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight lang="runbasic">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</syntaxhighlight>
<pre style="height: 40ex; overflow: scroll">
100 Samples used.
Mean = 0.514312738
Std Dev = 0.291627558
0 **************************************************************************************************
1 **********************************************************************
2 *********************
3 ***********************************
4 ***************************************************************
5 *******************************************************************************************
6 ***********************************************************************************************************************
7 **********************************************************************
8 ***************************************************************
9 **********************************************************************
1000 Samples used.
Mean = 0.495704208
Std Dev = 0.281389168
0 ***************************************************************
1 ********************************************************************
2 **************************************************************************
3 *******************************************************************************
4 **************************************************************************
5 **********************************************************************
6 ************************************************************************
7 **********************************************************************
8 ********************************************************
9 **********************************************************************
10000 Samples used.
Mean = 0.493594211
Std Dev = 0.288635912
0 ************************************************************************
1 ************************************************************************
2 **********************************************************************
3 *******************************************************************
4 **********************************************************************
5 ************************************************************************
6 ************************************************************************
7 *****************************************************************
8 **********************************************************************
9 ******************************************************************</pre>
==={{header|Yabasic}}===
{{trans|Run BASIC}}
<syntaxhighlight lang="vb">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</syntaxhighlight>
=={{header|C}}==
Line 805 ⟶ 1,819:
=={{header|CoffeeScript}}==
<syntaxhighlight lang="coffeescript">generate_statistics = (n) ->
hist = {}
Line 841 ⟶ 1,854:
for n in [100, 1000, 10000, 1000000]
[n, mean, stddev, hist] = generate_statistics n
display_statistics n, mean, stddev, hist</syntaxhighlight>
{{out}}
<pre>> coffee stats.coffee
-- Stats for sample size 100
mean: 0.5058459933893755
Line 1,202 ⟶ 2,211:
</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=easylang>
global list[] .
proc mklist n . .
list[] = [ ]
for i = 1 to n
list[] &= randomf
.
.
func mean .
for v in list[]
sum += v
.
return sum / len list[]
.
func stddev .
avg = mean
for v in list[]
squares += (avg - v) * (avg - v)
.
return sqrt (squares / len list[])
.
proc histo . .
len hist[] 10
for v in list[]
ind = floor (v * 10) + 1
hist[ind] += 1
.
for v in hist[]
h = floor (v / len list[] * 200 + 0.5)
s$ = substr "========================================" 1 h
print v & " " & s$
.
.
numfmt 4 5
proc stats size . .
mklist size
print "Size: " & size
print "Mean: " & mean
print "Stddev: " & stddev
histo
print ""
.
stats 100
stats 1000
stats 10000
stats 100000
</syntaxhighlight>
=={{header|Elixir}}==
Line 1,401 ⟶ 2,459:
end program</syntaxhighlight>
{{out}}
<pre>sample size = 100
Mean : 0.507952672404959
Stddev : 0.290452178516586
Line 1,456 ⟶ 2,513:
0.8: =================================================
0.9: ==================================================
1.0: =================================================</pre>
=={{header|Go}}==
Line 2,821 ⟶ 3,743:
0.9: ++++++++++++++++++++++++++++++++++++++++++++++++++
1.0: ++++++++++++++++++++++++</pre>
=={{header|Lua}}==
Line 3,381 ⟶ 4,244:
<!--</syntaxhighlight>-->
{{Out}}
<pre style="float:left; font-size:
-- Stats for sample size 100
mean: 0.530925
Line 3,396 ⟶ 4,259:
1.0: ========================================== 14
</pre>
<pre style="float:left; font-size:
-- Stats for sample size 1000
mean: 0.50576
Line 3,411 ⟶ 4,274:
1.0: ============================== 101
</pre>
<pre style="float:left; font-size:
-- Stats for sample size 10000
mean: 0.498831
Line 3,426 ⟶ 4,289:
1.0: ============================= 999
</pre>
<pre style="font-size:
-- Stats for sample size 1000000
mean: 0.499937
Line 3,558 ⟶ 4,421:
end stat;</syntaxhighlight>
{{out}}
<pre>Histogram for 100 values:
.......
..............
Line 3,573 ⟶ 4,435:
1000 values: mean= 4.97079E-0001 stddev= 1.07871E-0005
10000 values: mean= 4.99119E-0001 stddev= 8.35870E-0005
100000 values: mean= 5.00280E-0001 stddev= 7.88976E-0004 </pre>
=={{header|Python}}==
Line 4,169 ⟶ 4,926:
9
*********************************************************************
</pre>
=={{header|RPL}}==
Built-in statistics functions in RPL relies on a specific array named <code>∑DAT</code>, which is automatically generated when the first record is created by the word <code>∑+</code>.
{{works with|Halcyon Calc|4.2.8}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ → n
≪ CL∑ 1 n '''START''' RAND ∑+ '''NEXT'''
MEAN SDEV
{ 10 } 0 CON
1 n '''FOR''' j
∑DAT j { 1 } + GET
10 * 1 + FLOOR DUP2 GET 1 + PUT
'''NEXT'''
{ } 1 10 '''FOR''' j
OVER j GET 3 PICK RNRM / 20 *
"0." j 1 - →STR + "= " + 1 ROT '''START''' "*" + '''NEXT''' +
'''NEXT'''
≫ ≫ ‘<span style="color:blue">TASK</span>’ STO
|
<span style="color:blue">TASK</span> ''( #samples → statistics... ) ''
Generate and store samples in the statistics database
The easy part of the task
Create a 10-cell vector
Scan the database
Read the nth record
Increment the related cell
Generate histogramme
RNRM returns the max value of the 10-cell vector
|}
1000 <span style="color:blue">TASK</span>
{{out}}
<pre>
4: 0.492756012687
3: 0.29333176137
2: [ 120 100 90 86 112 113 90 87 97 105 ]
1: { "0.0= ********************"
"0.1= ****************"
"0.2= ***************"
"0.3= **************"
"0.4= ******************"
"0.5= ******************"
"0.6= ***************"
"0.7= **************"
"0.8= ****************"
"0.9= *****************" }
</pre>
Line 4,192 ⟶ 5,003:
[100, 1000, 10000].each {|n| generate_statistics n}</syntaxhighlight>
{{out}}
<pre style="height: 40ex; overflow: scroll">size: 100
mean: 0.5565132836634081
stddev: 0.30678831716883026
Line 4,235 ⟶ 5,044:
0.7:===================================================================
0.8:===================================================================
0.9:=================================================================</pre>
=={{header|Rust}}==
Line 4,512 ⟶ 5,233:
{{trans|Ruby}}
<syntaxhighlight lang="ruby">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 =
say "size: #{n}"
say "mean: #{mean}"
say "stddev: #{stddev}"
var max = hist.max
for i in ^hist
printf("%.1f:%s\n", 0.1*i, "=" * 70*hist[i]/max)
}
print "\n"
}
[100, 1000, 10000].each {|n| generate_statistics(n) }</syntaxhighlight>
{{out}}
<pre style="height: 40ex; overflow: scroll">
size: 100
mean: 0.539719181395696620109634051345884432579835159541
stddev: 0.283883840711089795862044996985935095942987013707
0.0:
0.1:
0.2:
0.3:======================================================================
0.4:==========================================================
0.5:======================================================================
0.6:
0.7:======================================================================
0.8:======================================================================
0.9:================================================================
size: 1000
mean: 0.509607463325018405029035982604757578351179500375
stddev: 0.291051486526422985516729469185300756396357843712
0.0:==========================================================
0.1:========================================================
0.2:================================================================
0.3:========================================================
0.4:
0.5:=====================================================================
0.6:
0.7:===========================================================
0.8:==========================================================
0.9:======================================================================
size: 10000
mean: 0.501370967820671948202377775772729161752514666335
stddev: 0.288601021921015908441703525737039264149088197141
0.0:
0.1:====================================================================
0.2:
0.3:=================================================================
0.4:======================================================================
0.5:=================================================================
0.6:===============================================================
0.7:===================================================================
0.8:==================================================================
0.9:====================================================================
</pre>
Line 4,733 ⟶ 5,454:
0,90-1,00 XXXXXXXXXX</pre>
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import rand
import math
Line 4,852 ⟶ 5,573:
=={{header|Wren}}==
{{libheader|Wren-math}}
<syntaxhighlight lang="
import "./math" for Nums
var r = Random.new()
Line 4,920 ⟶ 5,641:
0.4 - 0.5: **********
0.5 - 0.6: **********
0.6 - 0.7: **********
0.7 - 0.8: **********
0.8 - 0.9: **********
0.9 - 1.0: **********
</pre>
=={{header|XPL0}}==
{{trans|Wren}}
<syntaxhighlight lang "XPL0">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;
]</syntaxhighlight>
{{out}}
<pre>
For 100 random numbers:
mean = 0.516471700
stddev = 0.286590092
scale = 1 per asterisk
0.0 - 0.1: *********
0.1 - 0.2: ***********
0.2 - 0.3: ********
0.3 - 0.4: ********
0.4 - 0.5: **************
0.5 - 0.6: ***
0.6 - 0.7: **********
0.7 - 0.8: ******************
0.8 - 0.9: *********
0.9 - 1.0: **********
For 1000 random numbers:
mean = 0.485343800
stddev = 0.287769421
scale = 10 per asterisk
0.0 - 0.1: **********
0.1 - 0.2: ***********
0.2 - 0.3: *********
0.3 - 0.4: ***********
0.4 - 0.5: *********
0.5 - 0.6: ***********
0.6 - 0.7: ********
0.7 - 0.8: *********
0.8 - 0.9: ********
0.9 - 1.0: **********
For 10000 random numbers:
mean = 0.501502304
stddev = 0.288991280
scale = 100 per asterisk
0.0 - 0.1: *********
0.1 - 0.2: **********
0.2 - 0.3: **********
0.3 - 0.4: *********
0.4 - 0.5: *********
0.5 - 0.6: *********
0.6 - 0.7: **********
0.7 - 0.8: **********
| |||