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

 

 

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

<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

<pre>

</pre>

{{trans|python}}

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

 

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;

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

<pre>

</pre>

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

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

<pre>

2.000000 .000000

9.000000 2.000000

</pre>

 

=={{header|AutoHotkey}}==

 

=={{header|Axiom}}==

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

<pre>

Value = 2, running SD = 0

=={{header|C}}==

 

#include <stdlib.h>

#include <math.h>

 

 

typedef struct stat_obj_struct {

StatObject NewStatObject( Action action )

{

so = malloc(sizeof(sStatObject));

so->sum = 0.0;

so->sum += v;

so->sum2 += v*v;

 

 

int main()

FREE_STAT_OBJECT(so);

return 0;

 

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

using System.Collections.Generic;

using System.Linq;

}

}

<pre>0

1

1,39970842444753

2</pre>

 

=={{header|Clojure}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

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

(lambda (x)

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

 

 

=={{header|D}}==

 

struct StdDev {

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

}

<pre>0.000000e+00

1.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|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}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Go}}==

Algorithm to reduce rounding errors from WP article.

 

State maintained with a closure.

 

import (

fmt.Println(r(x))

}

<pre>

0

=={{header|Groovy}}==

Solution:

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

 

 

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

}

stddev (so far) := 1.0

stddev (so far) := 0.9428090415820626

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

}

public static void main(String[] args) {

double[] testData = {2,4,4,4,5,5,7,9};

StdDev sd = new StdDev();

for (double x : testData) {

}

}

 

=={{header|JavaScript}}==

Uses a closure.

var n = 0;

var sum = 0.0;

 

// using WSH

 

<pre>0, 1, 0.942809041582063, 0.866025403784439, 0.979795897113273, 1, 1.39970842444753, 2</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

</pre>

 

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

 

 

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

 

 

 

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

 

@interface SDAccum : NSObject

int main()

{

 

 

 

 

return 0;

 

===Blocks===

{{works with|iOS|4+}}

 

 

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

__block double sum = 0;

__block double sum2 = 0;

sum += x;

sum2 += x*x;

n++;

return sqrt(sum2/n - sum*sum/n/n);

}

 

int main()

{

 

 

 

 

return 0;

 

=={{header|OCaml}}==

 

let stddev l =

Printf.printf "List: ";

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

 

<pre>

List: 2 4 4 4 5 5 7 9

Standard deviation: 2

</pre>

 

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

2</pre>

 

 

 

 

 

 

=={{header|PicoLisp}}==

 

(de stdDev ()

(let Fun (stdDev)

(for N (2.0 4.0 4.0 4.0 5.0 5.0 7.0 9.0)

<pre>2.00 -> 0.00

4.00 -> 1.00

7.00 -> 1.40

9.00 -> 2.00</pre>

 

=={{header|PowerShell}}==

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

 

0.0000000000

1.0000000000

1.3997084244

2.0000000000

 

=={{header|Python}}==

>>> def sd(x):

sd.sum += x

(7, 1.3997084244475311)

(9, 2.0)

 

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

 

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

>>> def sdcreator():

sum = sum2 = n = 0

5 1.0

7 1.39970842445

 

{{Works with|Python|2.5+}}

>>> def sdcreator():

sum = sum2 = n = 0

5 1.0

7 1.39970842445

 

=={{header|R}}==

 

 

item 1: 2 average= 2 standard deviation= 0

item 2: 4 average= 3 standard deviation= 1

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

 

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

===With a Class===

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

variable sum sum2 num

constructor {} {

set sd [$sdacc value $val]

}

<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