Cumulative standard deviation: Difference between revisions

=={{header|11l}}==

{{trans|Python:_Callable_class}}

sum = 0.0

sum2 = 0.0

V sd_inst = SD()

L(value) [2, 4, 4, 4, 5, 5, 7, 9]

{{out}}

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

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

REAL sum,sum2

Print(" sd=") PrintRE(sd)

OD

{{out}}

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

=={{header|Ada}}==

with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;

with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;

end loop;

end Test_Deviation;

{{out}}

<pre>

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

OD

{{out}}

<pre>

A code sample in an object oriented style:

LONG REAL sum,

LONG REAL sum2,

)

{{out}}

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

{{Trans|ALGOL 68}}

This is an Algol W version of the third, "unpackaged" Algol 68 sample, which was itself translated from Python.

long real sum, sum2;

end for_i

{{out}}

<pre>

Accumulation over a fold:

-- stdDevInc :: Accumulator -> Num -> Index -> Accumulator

end script

end if

{{Out}}

Or as a map-accumulation:

-- cumulativeStdDevns :: [Float] -> [Float]

end script

end if

{{Out}}

=={{header|Arturo}}==

loop [2 4 4 4 5 5 7 9] 'value [

'arr ++ value

print [value "->" deviation arr]

{{out}}

=={{header|AutoHotkey}}==

for k, v in Data {

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

{{out}}

<pre>

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

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

No attempt to handle different types -- standard deviation is intrinsically a real number.

#include <assert.h>

#include <cmath>

}

}

=={{header|Clojure}}==

(defn stateful-std-deviation[x]

(letfn [(std-dev[x]

(intern *ns* 'v (atom [])))

(std-dev x)))

=={{header|COBOL}}==

{{works with|OpenCOBOL|1.1}}

PROGRAM-ID. run-stddev.

environment division.

goback.

end program stddev.

inp=002 stddev=+00000.0000

inp=004 stddev=+00001.0000

inp=007 stddev=+00001.3996

inp=009 stddev=+00002.0000

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

5 1.0

7 1.3997085

In the REPL, one step at a time:

#<Interpreted Closure (:INTERNAL RUNNING-STDDEV) @ #x21b9a492>

CL-USER> (funcall fn 2)

CL-USER> (funcall fn 9)

2.0

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

Use an object to keep state.

{{trans|Ruby}}

def initialize

@n, @sum, @sum2 = 0, 0.0, 0.0

sd = StdDevAccumulator.new

i = 0

{{out}}

<pre>

===Closure===

{{trans|Ruby}}

n, sum, sum2 = 0, 0.0, 0.0

->(num : Int32) do

sd = sdaccum

{{out}}

<pre>0.0, 1.0, 0.9428090415820634, 0.8660254037844386, 0.9797958971132712, 1.0, 1.3997084244475304, 2.0</pre>

=={{header|D}}==

struct StdDev {

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

}

{{out}}

<pre>0.000000e+00

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

{{trans|Erlang}}

def add_sample( pid, n ), do: send( pid, {:add, n} )

end

{{out}}

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

(let ((running-sum 0)

(running-len 0)

result))

{{out}}

{{libheader|Calc}}

{{libheader|generator.el}}

(require 'generator)

(generator (std-dev-gen test-data)))

(dolist (i test-data)

=={{header|Erlang}}==

-module( standard_deviation ).

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

01.10 S T(1)=2;S T(2)=4;S T(3)=4;S T(4)=4

01.20 S T(5)=5;S T(6)=5;S T(7)=7;S T(8)=9

02.10 S XN=0;S XS=0;S XQ=0

02.20 S XN=XN+1;S XS=XS+A;S XQ=XQ+A*A

{{out}}

=={{header|Forth}}==

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

fdup dup f+! float+

fdup f* f+!

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

( delta x )

dup f@ f- f* float+ f+! \ update nvar

Usage example:

2e stats st-add f. \ 0.

7e stats st-add f. \ 1.39970842444753

9e stats st-add f. \ 2.

=={{header|Fortran}}==

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

program standard_deviation

implicit none

end function stddev

end program standard_deviation

{{out}}

<pre>

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.

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.

=={{header|FreeBASIC}}==

Function calcStandardDeviation(number As Double) As Double

Print

Print "Press any key to quit"

{{out}}

State maintained with a closure.

import (

fmt.Println(r(x))

}

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

def stdDev = { def sample ->

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

println "${stdDev(it)}"

{{out}}

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

import Data.List (foldl') -- '

main = mapM_ print $ runST $

Or, perhaps more simply, as a map-accumulation over an indexed list:

--------------------------- TEST -------------------------

main :: IO ()

{{Out}}

<pre>0.0

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

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

}

{{out}}

<pre>stddev (so far) := 0.0

=={{header|IS-BASIC}}==

110 LET N=8

120 NUMERIC ARR(1 TO N)

240 PRINT J;"item =";ARR(J),"standard dev =";STDEV(J)

250 NEXT

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

Accumulating across a fold

return xs.reduce(function (a, x, i) {

}).stages

{{Out}}

====ES6====

As a map-accumulation:

'use strict';

// MAIN ---

return main();

{{Out}}

<pre>[

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.

∑x = ∑x² = zero(T)

n = 0

for i in test

println(" - add $i → ", rstd(i))

{{out}}

{{trans|Java}}

Using a class to keep the running sum, sum of squares and number of elements added so far:

class CumStdDev {

val csd = CumStdDev()

for (d in testData) println("Add $d => ${csd.sd(d)}")

{{out}}

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

=={{header|Lobster}}==

// Stats computes a running mean and variance

// See Knuth TAOCP vol 2, 3rd edition, page 232

test_stdv()

{{out}}

<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|Mathematica}}/{{header|Wolfram Language}}==

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

StdDeviator.count = 0

StdDeviator.sum = 0

sd.add x

end for

{{out}}

<pre>2</pre>

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

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

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

=={{header|Nanoquery}}==

{{trans|Java}}

declare n

declare sum

for x in testData

println sd.sd(x)

{{out}}

===Using global variables===

var sdSum, sdSum2, sdN = 0.0

for value in [float 2,4,4,4,5,5,7,9]:

{{out}}

===Using an accumulator object===

type SDAccum = object

for value in [float 2, 4, 4, 4, 5, 5, 7, 9]:

{{out}}

===Using a closure===

func accumBuilder(): auto =

for value in [float 2, 4, 4, 4, 5, 5, 7, 9]:

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

use Structure;

}

}

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

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

end

{{out}}

<pre>#1 value = 2 stdev = 0

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

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

8 item= 9 stddev= 2.000000000000000</pre>

==={{header|Delphi}}===

{$APPTYPE CONSOLE}

end;

Readln;

{{out}}

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

one-liner:

small script:

$d=new Math::StdDev;

foreach my $v ( 2,4,4,4,5,5,7,9 ) {

$d->Update($v);

print $d->variance(),"\n"

{{out}}

=={{header|Phix}}==

demo\rosetta\Standard_deviation.exw contains a copy of this code and a version that could be the basis for a library version that can handle multiple active data sets concurrently.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"N=%d Item=%d Avg=%5.3f StdDev=%5.3f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sdavg</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">sddev</span><span style="color: #0000FF;">()})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

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

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

{{out}}

<pre>2.00 -> 0.00

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

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

===Python: In a couple of 'functional' lines===

>>> myStd = lambda MyList : (reduce(lambda x,y : x + y , map(lambda x: (x-myMean(MyList))**2 , MyList)) / float(len(MyList)))**.5

>>> print myStd([2,4,4,4,5,5,7,9])

2.0