Cumulative standard deviation: Difference between revisions

{{task|Probability and statistics}}

 

Use this to compute the standard deviation of this demonstration set, <math>\{2, 4, 4, 4, 5, 5, 7, 9\}</math>, which is <math>2</math>.

 

* [[Random numbers]]

 

=={{header|360 Assembly}}==

For maximum compatibility, this program uses only the basic instruction set.

Part of the code length is due to the square root algorithm and to the nice output.

STDDEV CSECT

USING STDDEV,R13

BUF DC CL80'N=1 ITEM=1 AVG=1.234 STDDEV=1.234 '

YREGS

{{out}}

<pre>N=1 ITEM=2 AVG=2.000 STDDEV=0.000

N=7 ITEM=7 AVG=4.428 STDDEV=1.399

N=8 ITEM=9 AVG=5.000 STDDEV=2.000</pre>

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

procedure Test_Deviation is

type Sample is record

end record;

procedure Add (Data : in out Sample; Point : Float) is

begin

Data.N := Data.N + 1;

end Add;

function Deviation (Data : Sample) return Float is

begin

end Deviation;

 

Data : Sample;

begin

end loop;

{{out}}

<pre>

 

=={{header|ALGOL 68}}==

{{trans|C}}

 

{{works with|ALGOL 68|Standard - no extensions to language used}}

 

 

<!-- {{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8.8d.fc9.i386]}} -->

Note: the use of a UNION to mimic C's enumerated types is "experimental" and probably not typical of "production code". However it is a example of '''ALGOL 68'''s ''conformity CASE clause'' useful for classroom dissection.

STDDEV = STRUCT(CHAR stddev),

MEAN = STRUCT(CHAR mean),

COUNT = STRUCT(CHAR count),

RESET = STRUCT(CHAR reset);

MODE ACTION = UNION ( VALUE, STDDEV, MEAN, VAR, COUNT, RESET );

LONG REAL sum := 0;

LONG REAL sum2 := 0;

INT num := 0;

PROC stat object = (LONG REAL v, ACTION action)LONG REAL:

(

ESAC

);

[]LONG REAL v = ( 2,4,4,4,5,5,7,9 );

FOR i FROM LWB v TO UPB v DO

{{out}}

<pre>

</pre>

 

{{trans|python}}

{{works with|ALGOL 68|Standard - no extensions to language used}}

<!-- {{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8.8d.fc9.i386]}} -->

 

A code sample in an object oriented style:

LONG REAL sum,

LONG REAL sum2,

INT num

);

OP INIT = (REF STAT new)REF STAT:

(init OF class stat)(new);

MODE CLASSSTAT = STRUCT(

PROC (REF STAT, LONG REAL #value#)VOID plusab,

CLASSSTAT class stat;

plusab OF class stat := (REF STAT self, LONG REAL value)VOID:(

num OF self +:= 1;

sum2 OF self +:= value*value

);

OP +:= = (REF STAT lhs, LONG REAL rhs)VOID: # some syntatic sugar #

(plusab OF class stat)(lhs, rhs);

stddev OF class stat := (REF STAT self)LONG REAL:

long sqrt((variance OF class stat)(self));

OP STDDEV = ([]LONG REAL value)LONG REAL: ( # more syntatic sugar #

REF STAT stat = INIT LOC STAT;

(stddev OF class stat)(stat)

);

mean OF class stat := (REF STAT self)LONG REAL:

sum OF self/LONG REAL(num OF self);

variance OF class stat := (REF STAT self)LONG REAL:(

LONG REAL m = (mean OF class stat)(self);

sum2 OF self/LONG REAL(num OF self)-m*m

);

count OF class stat := (REF STAT self)LONG REAL:

num OF self;

init OF class stat := (REF STAT self)REF STAT:(

sum OF self := sum2 OF self := num OF self := 0;

self

);

[]LONG REAL value = ( 2,4,4,4,5,5,7,9 );

main:

(

REF STAT stat = INIT LOC STAT;

FOR i FROM LWB value TO UPB value DO

printf(($"standard deviation = "g(0,6)l$, (stddev OF class stat)(stat)));

printf(($"mean = "g(0,6)l$, (mean OF class stat)(stat)));

printf(($"variance = "g(0,6)l$, (variance OF class stat)(stat)));

printf(($"count = "g(0,6)l$, (count OF class stat)(stat)))

{{out}}

<pre>

</pre>

 

 

A simple - but "unpackaged" - code example, useful if the standard deviation is required on only one set of concurrent data:

INT n;

 

LONG REAL value = values[i];

printf(($2(xg(0,6))l$, value, sd(value)))

{{out}}

<pre>

9.000000 2.000000

</pre>

 

=={{header|AutoHotkey}}==

 

 

=={{header|AWK}}==

# syntax: GAWK -f STANDARD_DEVIATION.AWK

BEGIN {

return(sqrt(variance))

}

{{out}}

<pre>

=={{header|Axiom}}==

{{incorrect|Axiom|It does not return the ''running'' standard deviation of the series.}}

TestDomain(T : Join(Field,RadicalCategory)): Exports == Implementation where

R ==> Record(n : Integer, sum : T, ssq : T)

sd obj ==

mean : T := obj.sum / (obj.n::T)

D ==> TestDomain(T)

items := [2,4,4,4,5,5,7,9+x] :: List T;

 

(2) 2

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Uses the MOD(array()) and SUM(array()) functions.

FOR i% = 1 TO 8

READ n

i% += 1

list(i%) = n

{{out}}

<pre>

=={{header|C}}==

 

#include <stdlib.h>

#include <math.h>

so->sum2 += v*v;

return stat_obj_value(so, so->action);

 

 

int main()

FREE_STAT_OBJECT(so);

return 0;

 

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

using System.Collections.Generic;

using System.Linq;

}

}

<pre>0

1

2</pre>

 

 

 

 

 

 

 

 

PROCEDURE DIVISION.

IDENTIFICATION DIVISION.

 

=={{header|CoffeeScript}}==

Uses a class instance to maintain state.

 

class StandardDeviation

constructor: ->

 

"""

 

{{out}}

 

=={{header|Common Lisp}}==

(let ((sum 0) (sq 0) (n 0))

(lambda (x)

(/ (sqrt (- (* n sq) (* sum sum))) n))))

 

 

=={{header|Component Pascal}}==

{{incorrect|Component Pascal|Function does not take numbers individually.}}

BlackBox Component Builder

MODULE StandardDeviation;

IMPORT StdLog, Args,Strings,Math;

END Do;

END StandardDeviation.

Execute: ^Q StandardDeviation.Do 2 4 4 4 5 5 7 9 ~<br/>

{{out}}

8 :> 2.0

</pre>

 

=={{header|D}}==

 

struct StdDev {

writefln("%e", stdev.getStdDev());

}

{{out}}

<pre>0.000000e+00

 

=={{header|Delphi}}==

 

=={{header|E}}==

The algorithm is {{trans|Perl}} and the results were checked against [[#Python]].

 

var sum := 0.0

var sumSquares := 0.0

return [insert, stddev]

 

# value: <insert>, <stddev>

 

1.0

1.3997084244475297

 

=={{header|Emacs Lisp}}==

 

 

 

 

 

=={{header|Erlang}}==

-module( standard_deviation ).

 

[add_print(Pid, X, add_sample(Pid, X)) || X <- [2,4,4,4,5,5,7,9]],

destroy( Pid ).

 

add_print( Pid, N, _Add ) -> io:fwrite( "Standard deviation ~p when adding ~p~n", [get(Pid), N] ).

 

loop_calculate_average( Ns ) -> lists:sum( Ns ) / erlang:length( Ns ).

{{out}}

<pre>

 

=={{header|Factor}}==

sequences ;

IN: standard-deviator

{ 2 4 4 4 5 5 7 9 }

<standard-deviator> [ [ add-value ] curry each ] keep

 

=={{header|Forth}}==

 

: st-count ( stats -- n ) f@ ;

: st-sum ( stats -- sum ) float+ f@ ;

: st-sumsq ( stats -- sum*sum ) 2 floats + f@ ;

 

: st-mean ( stats -- mean )

 

: st-stddev ( stats -- stddev )

This variation is more numerically stable when there are large numbers of samples or large sample ranges.

: st-mean ( stats -- mean ) float+ f@ ;

: st-nvar ( stats -- n*var ) 2 floats + f@ ;

 

: st-add ( x stats -- )

1e dup f+! \ update count

fdup dup st-mean f- fswap

float+ dup f+! \ update mean

( delta x )

 

 

=={{header|Fortran}}==

 

 

 

end do

 

contains

 

 

else

 

 

 

 

===Old style, four ways===

 

With more complex operating systems, routines that relied on retaining values across invocations might no longer work - perhaps a fresh version of the routine would be loaded to memory (perhaps at odd intervals), or, on exit, the working storage would be discarded. There was a half-way scheme, whereby variables that had appeared in DATA statements would be retained while the others would be discarded. This subtle indication has been discarded in favour of the explicit SAVE statement, naming those variables whose values are to be retained between invocations, though compilers might also offer an option such as "automatic" (for each invocation always allocate then discard working memory) and "static" (retain values), possibly introducing non-standard keywords as well. Otherwise, the routines would have to use storage global to them such as additional parameters, or, COMMON storage and in later Fortran, the MODULE arrangements for shared items. The persistence of such storage can still be limited, but by naming them in the main line can be ensured for the life of the run. The other routines with access to such storage could enable re-initialisation, additional reports, or multiple accumulations, etc.

 

Incidentally, Fortran implementations rarely enable re-entrancy for the WRITE statement, so, since here the functions are invoked in a WRITE statement, the functions cannot themselves use WRITE statements, say for debugging.

REAL FUNCTION STDDEV(X) !Standard deviation for successive values.

REAL X !The latest value.

EX2 = X**2 + EX2 !Augment the sum of squares.

V = EX2/N - (EX/N)**2 !The variance, but, it might come out negative!

END FUNCTION STDDEV !For the sequence of received X values.

 

SAVE N,A,V !Retain values from one invocation to the next.

DATA N,A,V/0,0.0,0.0/ !Initial values.

V = (N - 1)*(X - A)**2 /N + V !First, as it requires the existing average.

A = (X - A)/N + A != [x + (n - 1).A)]/n: recover the total from the average.

EX2 = D**2 + EX2 !Augment the sum of squares.

V = EX2/N - (EX/N)**2 !The variance, but, it might come out negative!

END FUNCTION STDDEVW !For the sequence of received X values.

 

SAVE N,A,V,W !Retain values from one invocation to the next.

DATA N,A,V/0,0.0,0.0/ !Initial values.

D = X - W !Its deviation from the working mean.

V = (N - 1)*(D - A)**2 /N + V !First, as it requires the existing average.

END DO !On to the next value.

END

 

Output: the second pair of columns have the calculations done with a working mean and thus accumulate deviations from that.

 

In other words, a two-pass method will be more accurate (where the second pass calculates the variance by accumulating deviations from the actual average, itself calculated with a working mean) but at the cost of that second pass and the saving of all the values. Higher precision variables for the accumulations are the easiest way towards accurate results.

 

=={{header|Go}}==

 

State maintained with a closure.

 

import (

fmt.Println(r(x))

}

{{out}}

<pre>

 

=={{header|Groovy}}==

Solution:

[2,4,4,4,5,5,7,9].each {

 

{{out}}

 

=={{header|Haskell}}==

We store the state in the <code>ST</code> monad using an <code>STRef</code>.

 

import Data.STRef

import Control.Monad.ST

 

 

 

 

=={{header|Haxe}}==

 

class Main {

return Math.sqrt(average(store));

}

<pre>0

1

 

=={{header|HicEst}}==

 

set = (2,4,4,4,5,5,7,9)

sum2 = sum2 + x*x

stdev = ( sum2/k - (sum/k)^2) ^ 0.5

<pre>Adding 2 stdev = 0

Adding 4 stdev = 1

 

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

 

stddev() # reset state / empty

end

 

static X,sumX,sum2X

 

return sqrt( (sum2X / *X) - (sumX / *X)^2 )

}

{{out}}

<pre>stddev (so far) := 0.0

stddev (so far) := 1.39970842444753

stddev (so far) := 2.0</pre>

 

=={{header|J}}==

 

J is block-oriented; it expresses algorithms with the semantics of all the data being available at once. It does not have native lexical closure or coroutine semantics. It is possible to implement these semantics in J; see [[Moving Average]] for an example. We will not reprise that here.

dev=: - mean

stddevP=: [: %:@mean *:@dev NB. A) 3 equivalent defs for stddevP

 

stddevP\ 2 4 4 4 5 5 7 9

 

'''Alternatives:'''<br>

Using verbose names for J primitives.

sqrt =: %:

sum =: +/

 

stddevP\ 2 4 4 4 5 5 7 9

 

{{trans|R}}<BR>

Or we could take a cue from the [[#R|R implementation]] and reverse the Bessel correction to stddev:

 

(%:@:(%~<:)@:# * stddev)\ 2 4 4 4 5 5 7 9

 

=={{header|Java}}==

int n = 0;

double sum = 0;

}

}

 

=={{header|JavaScript}}==

Uses a closure.

var n = 0;

var sum = 0.0;

 

// using WSH

 

{{out}}

<pre>0, 1, 0.942809041582063, 0.866025403784439, 0.979795897113273, 1, 1.39970842444753, 2</pre>

 

=={{header|jq}}==

where SSD is the sum of squared deviations about the mean.

 

# seen so far, given the current state as input:

def standard_deviation: .ssd / .n | sqrt;

 

# Begin:

'''Example 1'''

# observations.txt

9

{{Out}}

$ jq -s -f Dynamic_standard_deviation.jq observations.txt

0

1.3997084244475302

1.9999999999999998

====Observations from a stream====

Recent versions of jq (after 1.4) support retention of state while processing a stream. This means that any generator (including generators that produce items indefinitely) can be used as the source of observations, without first having to capture all the observations, e.g. in a file or array.

def simulate(stream):

foreach stream as $observation

(initial_state;

update_state($observation);

'''Example 2''':

simulate( range(0;10) )

 

The definitions of the filters update_state/1 and initial_state/0 are as above but are repeated so that this script is self-contained.

 

# jq is assumed to be on PATH

sed -n 1p <<< "$result"

state=$(sed -n 2p <<< "$result")

'''Example 3'''

Next observation: 10

0

Next observation: 0

8.16496580927726

 

=={{header|Julia}}==

Use a closure to create a running standard deviation function.

function runningstd(x)

end

return runningstd

end

 

rstd = makerunningstd()

 

println("Perform a running standard deviation of ", test)

for i in test

 

{{out}}

<pre>

</pre>

 

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

Using a global array to maintain the state. Implements definition explicitly.

dim SD.storage$( 100) ' can call up to 100 versions, using ID to identify.. arrays are global.

' holds (space-separated) number of data items so far, current sum.of.values and current sum.of.squares

 

Data 2, 4, 4, 4, 5, 5, 7, 9

<pre>

New data 2 so S.D. now = 0.000000

New data 7 so S.D. now = 1.399708

New data 9 so S.D. now = 2.000000

</pre>

 

=={{header|Lua}}==

Uses a closure. Translation of JavaScript.

local sum, sumsq, k = 0,0,0

return function(n)

for i, v in ipairs{2,4,4,4,5,5,7,9} do

print(ldev(v))

 

 

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

The simple form is, computing only the standand deviation of the whole data set:

 

n = length (x);

 

x2 = mean (x .* x);

dev= sqrt (x2 - m * m)

 

When the intermediate results are also needed, one can use this vectorized form:

 

x2= cumsum(x.^2) ./ [1:n]; % running squares

 

0.00000 1.00000 0.94281 0.86603 0.97980 1.00000 1.39971 2.00000

 

 

Here is a vectorized one line solution as a function

function stdDevEval(n)

disp(sqrt(sum((n-sum(n)/length(n)).^2)/length(n)));

end

 

=={{header|МК-61/52}}==

x^2 ИП6 + П6 КИП4 ИП6 ИП4 / ИП5 ИП4

 

Instruction: В/О С/П ''number'' С/П ''number'' С/П ...

 

=={{header|Nim}}==

 

var sdSum, sdSum2, sdN = 0.0

 

{{out}}

4 1

4 0.942809

7 1.39971

9 2</pre>

=={{header|Objective-C}}==

 

@interface SDAccum : NSObject

}

return 0;

 

===Blocks===

{{works with|iOS|4+}}

 

 

typedef double (^Func)(double); // a block that takes a double and returns a double

}

return 0;

 

=={{header|OCaml}}==

 

let stddev l =

Printf.printf "List: ";

List.iter (Printf.printf "%g ") l;

 

{{out}}

Here, we create a channel to hold current list of numbers. Constraint is that this channel can't hold mutable objects. On the other hand, stddev function is thread safe and can be called by tasks running in parallel.

 

 

: stddev(x)

| l |

StdValues receive x + dup ->l StdValues send drop

 

{{out}}

=={{header|ooRexx}}==

{{works with|oorexx}}

x = .array~of(2,4,4,4,5,5,7,9)

sd = 0

do i = 1 to x~size

sd = sdacc~value(x[i])

end

 

::class SDAccum

ans = ( prev + ( n / prev ) ) / 2

end

 

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

Uses the Cramer-Young updating algorithm. For demonstration it displays the mean and variance at each step.

myT=x;

myS=0;

print("Standard deviation: ",sqrt(myS/myN))

};

 

=={{header|Pascal}}==

{{trans|AWK}}

uses math;

const

writeln(i,' item=',arr[i]:2:0,' stddev=',stddev(i):18:15)

end

{{out}}

<pre>1 item= 2 stddev= 0.000000000000000

7 item= 7 stddev= 1.399708424447530

8 item= 9 stddev= 2.000000000000000</pre>

 

=={{header|Perl}}==

package SDAccum;

sub new {

return $self->stddev;

}

 

my $sd;

 

$sd = $sdacc->value($v);

}

 

A much shorter version using a closure and a property of the variance:

 

{

my $num, $sum, $sum2;

}

 

 

{{out}}

2</pre>

 

 

 

{{out}}

1

0.942809041582063

1.39970842444753

2</pre>

=={{header|PHP}}==

This is just straight PHP class usage, respecting the specifications "stateful" and "one at a time":

class sdcalc {

private $cnt, $sumup, $square;

foreach ([2,4,4,4,5,5,7,9] as $v) {

printf('Adding %g: result %g%s', $v, $c->add($v), PHP_EOL);

 

This will produce the output:

Adding 9: result 2

</pre>

 

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

stddev: proc options(main);

declare a(10) float init(1,2,3,4,5,6,7,8,9,10);

end std_dev;

{{out}}

<pre>AVERAGE= 5.50000E+0000;

Standard deviation 2.87228E+0000 </pre>

 

=={{header|PowerShell}}==

This implementation takes the form of an advanced function

which can act like a cmdlet and receive input from the pipeline.

begin {

$avg = 0

[Math]::Sqrt($sum / $nums.Length)

}

Usage as follows:

<pre>PS> 2,4,4,4,5,5,7,9 | Get-StandardDeviation

 

=={{header|PureBasic}}==

Declare.d Standard_deviation(x)

 

MyList:

Data.i 2,4,4,4,5,5,7,9

 

{{out}}

The program should work with Python 2.x and 3.x,

although the output would not be a tuple in 3.x

>>> def sd(x):

sd.sum += x

(7, 1.3997084244475311)

(9, 2.0)

 

===Python: Using a class instance===

def __init__(self):

self.sum, self.sum2, self.n = (0,0,0)

>>> sd_inst = SD()

>>> for value in (2,4,4,4,5,5,7,9):

 

====Python: Callable class====

===Python: Using a Closure===

{{Works with|Python|3.x}}

>>> def sdcreator():

sum = sum2 = n = 0

5 1.0

7 1.39970842445

 

===Python: Using an extended generator===

{{Works with|Python|2.5+}}

>>> def sdcreator():

sum = sum2 = n = 0

5 1.0

7 1.39970842445

 

=={{header|R}}==

 

=={{header|Racket}}==

 

#lang racket

(require math)

;; run it on each number, return the last result

(last (map running-stddev '(2 4 4 4 5 5 7 9)))

 

 

<pre>

item 1: 2 average= 2 standard deviation= 0

item 7: 7 average= 4.42857143 standard deviation= 1.39970843

item 8: 9 average= 5 standard deviation= 2

</pre>

 

"Simplification of the formula [...] for standard deviation [...] can be memorized as taking the square root of (the average of the squares less the square of the average)." [[wp:Standard_deviation#Simplification_of_the_formula|c.f. wikipedia]].

 

def initialize

@n, @sum, @sumofsquares = 0, 0.0, 0.0

sd = StdDevAccumulator.new

i = 0

 

<pre>adding 2: stddev of 1 samples is 0.0

 

=== Closure ===

n, sum, sum2 = 0, 0.0, 0.0

lambda do |num|

 

sd = sdaccum

 

<pre>0.0, 1.0, 0.942809041582063, 0.866025403784439, 0.979795897113272, 1.0, 1.39970842444753, 2.0, </pre>

 

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

'holds (space-separated) number of data , sum of values and sum of squares

sd$ = "2,4,4,4,5,5,7,9"

print num;" value in = ";stdData; " Stand Dev = "; using("###.######", standDev)

 

<pre>1 value in = 2 Stand Dev = 0.000000

2 value in = 4 Stand Dev = 1.000000

7 value in = 7 Stand Dev = 1.399708

8 value in = 9 Stand Dev = 2.000000</pre>

 

=={{header|SAS}}==

*--Load the test data;

data test1;

var n sd /*mean*/;

run;

 

{{out}}

8 2.00000

</pre>

 

=={{header|Scala}}==

{{libheader|Scala}}

 

object StddevCalc extends App {

 

def calcAvgAndStddev[T](ts: Iterable[T])(implicit num: Fractional[T]): (T, Double) = {

(mean, stdDev)

}

 

println(calcAvgAndStddev(List(2.0E0, 4.0, 4, 4, 5, 5, 7, 9)))

println(calcAvgAndStddev(0.1 to 1.1 by 0.05))

println(calcAvgAndStddev(List(BigDecimal(120), BigDecimal(1200))))

 

=={{header|Scheme}}==

 

=={{header|Scilab}}==

Scilab has the built-in function '''stdev''' to compute the standard deviation of a sample so it is straightforward to have the standard deviation of a sample with a correction of the bias.

{{out}}

<pre>-->T=[2,4,4,4,5,5,7,9];

-->stdev(T)*sqrt((length(T)-1)/length(T))

ans = 2.</pre>

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

|sum sum2 num|

SDAccum class >> new [ |o|

]

stddev [ ^ (self variance) sqrt ]

 

sdacc := SDAccum new.

 

#( 2 4 4 4 5 5 7 9 ) do: [ :v | sd := sdacc value: v ].

=={{header|SQL}}==

{{works with|Postgresql}}

create table if not exists teststd (n double precision not null);

 

-- cleanup test data

delete from teststd;

With a command like '''psql <rosetta-std-dev.sql''' you will get an output like this: (duplicate lines generously deleted, locale is DE)

<pre>

 

=={{header|Swift}}==

class stdDev{

}

{{out}}

<pre>

Functional:

 

func standardDeviation(arr : [Double]) -> Double

{

standardDeviation(responseTimes) // 20.8742514835862

standardDeviation([2,4,4,4,5,5,7,9]) // 2.0

 

=={{header|Tcl}}==

===With a Class===

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

variable sum sum2 num

constructor {} {

set sd [$sdacc value $val]

}

{{out}}

<pre>the standard deviation is: 2.0</pre>

===With a Coroutine===

{{works with|Tcl|8.6}}

coroutine sd apply {{} {

set sum 0.0

}

sd stop

 

[[Category:Stateful transactions]]

 

=={{header|VBScript}}==

 

For i = 0 To UBound(data)

variance = variance/(n+1)

sd = FormatNumber(Sqr(variance),6)

 

{{Out}}

Note that the helper function <code>avg</code> is not named <code>average</code> to avoid a name conflict with <code>WorksheetFunction.Average</code> in MS Excel.

 

'treats non-numeric strings as zero

Dim L0 As Variant, total As Variant

Debug.Print standardDeviation(x(L0))

Next

 

{{out}}

1.39970842444753

2

</pre>

 

=={{header|XPL0}}==

int A, I;

real N, S, S2;

];

CrLf(0);

 

{{out}}

 

=={{header|zkl}}==

m:=xs.append(x.toFloat()).sum(0.0)/xs.len();

(xs.reduce('wrap(p,x){(x-m)*(x-m) +p},0.0)/xs.len()).sqrt()

}.fp1(L())

{{out}}

<pre>