Averages/Simple moving average: Difference between revisions

{{task|Probability and statistics}}

Computing the [[wp:Moving_average#Simple_moving_average|simple moving average]] of a series of numbers.

 

 

 

=={{header|AutoHotkey}}==

ahk forum: [http://www.autohotkey.com/forum/post-276695.html#276695 discussion]

For Integers:

MsgBox % MovingAverage(1) ; 3

MsgBox % MovingAverage(-3) ; 1

v%i% := x, i := mod(i+1,m) ; remember last m inputs, cycle insertion point

Return sum/n

For floating point numbers:

Static

Static n:=0, m:=10 ; default averaging length = 10

j := A_Index-1, sum += v%j%

Return sum/n

 

=={{header|C}}==

#include <stdlib.h>

#include <stdarg.h>

va_end(vl);

return r;

 

 

int main()

sma(SMA_FREE, h5);

return 0;

 

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

This implementation uses a circular list to store the numbers within the window; at the beginning of each iteration <var>pointer</var> refers to the list cell which holds the value just moving out of the window and to be replaced with the just-added value.

 

(sum 0) (count 0) (values (make-list period)) (pointer values))

(setf (rest (last values)) values) ; construct circularity

(setf (first pointer) n)

(setf pointer (rest pointer)) ; advance pointer

 

=={{header|E}}==

 

 

The structure is the same as the implementation of [[Standard Deviation#E]].

 

def makeMovingAverage(period) {

def values := ([null] * period).diverge()

return [insert, average]

 

> def [insert, average] := makeMovingAverage(period)

> println(`Period $period:`)

3 4.2

2 3.8

 

=={{header|Forth}}==

: ,f0s ( n -- ) falign 0 do 0e f, loop ;

 

2e sma f. \ 1.5

3e sma f. \ 2.

 

=={{header|Fortran}}==

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

implicit none

 

end function

 

 

=={{header|J}}==

'''Note''': J is block-oriented, not stream oriented. That is, J expresses algorithms with the semantics that all the data is available at once (rather than maintaining state and waiting for the next item).

 

 

 

=={{header|Java}}==

{{works with|Java|1.5+}}

public class MovingAverage {

}

public static void main(String[] args) {

MovingAverage ma = new MovingAverage(windSize);

for (double x : testData) {

ma.newNum(x);

}

System.out.println();

}

}

 

}

 

}

<pre>1.0

1.5

3.8

3.0</pre>

 

=={{header|Perl}}==

 

=={{header|Python}}==

 

assert period == int(period) and period > 0, "Period must be an integer >0"

summ = n = 0.0

 

def sma(x):

return summ / n

 

 

 

for period in [3, 5]:

sma = simplemovingaverage(period)

for i in range(1,6):

print (" Next number = %-2g, SMA = %g " % (i, sma(i)))

for i in range(5, 0, -1):

 

Next number = 1 , SMA = 1

Next number = 2 , SMA = 1.5

Next number = 1 , SMA = 2

 

Next number = 1 , SMA = 1

Next number = 2 , SMA = 1.5

Next number = 2 , SMA = 3.8

Next number = 1 , SMA = 3 </pre>

 

=={{header|R}}==

This is easiest done with two functions: one to handle the state (i.e. the numbers already entered), and one to calculate the average.

lastvalues <- local(

{

moving.average(-3) # 1

moving.average(8) # 2